home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 July: Mac OS SDK / Dev.CD Jul 97 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Interfaces / AIncludes / LowMem.a < prev    next >
Encoding:
Text File  |  1996-01-24  |  72.5 KB  |  4,329 lines  |  [TEXT/MPS ]

  1. ;
  2. ;    File:        LowMem.a
  3. ;
  4. ;    Contains:    Low Memory Accessor Interfaces.
  5. ;
  6. ;    Version:    Technology:    System 7.5
  7. ;                Package:    Universal Interfaces 2.2 in “MPW” on ETO #20
  8. ;
  9. ;    Copyright:    © 1984-1995 by Apple Computer, Inc.
  10. ;                All rights reserved.
  11. ;
  12. ;    Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13. ;                stack.  Include the file and version information (from above)
  14. ;                in the problem description and send to:
  15. ;                    Internet:    apple.bugs@applelink.apple.com
  16. ;                    AppleLink:    APPLE.BUGS
  17. ;
  18. ;
  19.  
  20.     IF &TYPE('__LOWMEM__') = 'UNDEFINED' THEN
  21. __LOWMEM__ SET 1
  22.  
  23.  
  24.     IF &TYPE('__TYPES__') = 'UNDEFINED' THEN
  25.     include 'Types.a'
  26.     ENDIF
  27. ;        include 'ConditionalMacros.a'                                ;
  28.  
  29.     IF &TYPE('__CONTROLS__') = 'UNDEFINED' THEN
  30.     include 'Controls.a'
  31.     ENDIF
  32. ;        include 'Quickdraw.a'                                        ;
  33. ;            include 'MixedMode.a'                                    ;
  34. ;            include 'QuickdrawText.a'                                ;
  35. ;        include 'Menus.a'                                            ;
  36. ;            include 'Memory.a'                                        ;
  37.  
  38.     IF &TYPE('__EVENTS__') = 'UNDEFINED' THEN
  39.     include 'Events.a'
  40.     ENDIF
  41. ;        include 'OSUtils.a'                                        ;
  42.  
  43.     IF &TYPE('__FILES__') = 'UNDEFINED' THEN
  44.     include 'Files.a'
  45.     ENDIF
  46. ;        include 'Finder.a'                                            ;
  47.  
  48.     IF &TYPE('__FONTS__') = 'UNDEFINED' THEN
  49.     include 'Fonts.a'
  50.     ENDIF
  51.  
  52.     IF &TYPE('__MEMORY__') = 'UNDEFINED' THEN
  53.     include 'Memory.a'
  54.     ENDIF
  55.  
  56.     IF &TYPE('__MENUS__') = 'UNDEFINED' THEN
  57.     include 'Menus.a'
  58.     ENDIF
  59.  
  60.     IF &TYPE('__OSUTILS__') = 'UNDEFINED' THEN
  61.     include 'OSUtils.a'
  62.     ENDIF
  63.  
  64.     IF &TYPE('__QUICKDRAW__') = 'UNDEFINED' THEN
  65.     include 'Quickdraw.a'
  66.     ENDIF
  67.  
  68.     IF &TYPE('__RESOURCES__') = 'UNDEFINED' THEN
  69.     include 'Resources.a'
  70.     ENDIF
  71.  
  72.     IF &TYPE('__WINDOWS__') = 'UNDEFINED' THEN
  73.     include 'Windows.a'
  74.     ENDIF
  75. ;
  76. ; pascal SInt16 LMGetScrVRes(void)
  77. ;
  78.     IF ¬ GENERATINGCFM THEN
  79.         Macro
  80.         _LMGetScrVRes         &dest=(sp)
  81.         move.w               $0102,&dest
  82.         EndM
  83.     ELSE
  84.         IMPORT_CFM_FUNCTION    LMGetScrVRes
  85.     ENDIF
  86.  
  87. ;
  88. ; pascal void LMSetScrVRes(SInt16 value)
  89. ;
  90.     IF ¬ GENERATINGCFM THEN
  91.         Macro
  92.         _LMSetScrVRes         &src=(sp)+
  93.         move.w               &src,$0102
  94.         EndM
  95.     ELSE
  96.         IMPORT_CFM_FUNCTION    LMSetScrVRes
  97.     ENDIF
  98.  
  99. ;
  100. ; pascal SInt16 LMGetScrHRes(void)
  101. ;
  102.     IF ¬ GENERATINGCFM THEN
  103.         Macro
  104.         _LMGetScrHRes         &dest=(sp)
  105.         move.w               $0104,&dest
  106.         EndM
  107.     ELSE
  108.         IMPORT_CFM_FUNCTION    LMGetScrHRes
  109.     ENDIF
  110.  
  111. ;
  112. ; pascal void LMSetScrHRes(SInt16 value)
  113. ;
  114.     IF ¬ GENERATINGCFM THEN
  115.         Macro
  116.         _LMSetScrHRes         &src=(sp)+
  117.         move.w               &src,$0104
  118.         EndM
  119.     ELSE
  120.         IMPORT_CFM_FUNCTION    LMSetScrHRes
  121.     ENDIF
  122.  
  123. ;
  124. ; pascal Ptr LMGetMemTop(void)
  125. ;
  126.     IF ¬ GENERATINGCFM THEN
  127.         Macro
  128.         _LMGetMemTop         &dest=(sp)
  129.         move.l               $0108,&dest
  130.         EndM
  131.     ELSE
  132.         IMPORT_CFM_FUNCTION    LMGetMemTop
  133.     ENDIF
  134.  
  135. ;
  136. ; pascal void LMSetMemTop(Ptr value)
  137. ;
  138.     IF ¬ GENERATINGCFM THEN
  139.         Macro
  140.         _LMSetMemTop         &src=(sp)+
  141.         move.l               &src,$0108
  142.         EndM
  143.     ELSE
  144.         IMPORT_CFM_FUNCTION    LMSetMemTop
  145.     ENDIF
  146.  
  147. ;
  148. ; pascal Ptr LMGetBufPtr(void)
  149. ;
  150.     IF ¬ GENERATINGCFM THEN
  151.         Macro
  152.         _LMGetBufPtr         &dest=(sp)
  153.         move.l               $010C,&dest
  154.         EndM
  155.     ELSE
  156.         IMPORT_CFM_FUNCTION    LMGetBufPtr
  157.     ENDIF
  158.  
  159. ;
  160. ; pascal void LMSetBufPtr(Ptr value)
  161. ;
  162.     IF ¬ GENERATINGCFM THEN
  163.         Macro
  164.         _LMSetBufPtr         &src=(sp)+
  165.         move.l               &src,$010C
  166.         EndM
  167.     ELSE
  168.         IMPORT_CFM_FUNCTION    LMSetBufPtr
  169.     ENDIF
  170.  
  171. ;
  172. ; pascal Ptr LMGetHeapEnd(void)
  173. ;
  174.     IF ¬ GENERATINGCFM THEN
  175.         Macro
  176.         _LMGetHeapEnd         &dest=(sp)
  177.         move.l               $0114,&dest
  178.         EndM
  179.     ELSE
  180.         IMPORT_CFM_FUNCTION    LMGetHeapEnd
  181.     ENDIF
  182.  
  183. ;
  184. ; pascal void LMSetHeapEnd(Ptr value)
  185. ;
  186.     IF ¬ GENERATINGCFM THEN
  187.         Macro
  188.         _LMSetHeapEnd         &src=(sp)+
  189.         move.l               &src,$0114
  190.         EndM
  191.     ELSE
  192.         IMPORT_CFM_FUNCTION    LMSetHeapEnd
  193.     ENDIF
  194.  
  195. ;
  196. ; pascal THz LMGetTheZone(void)
  197. ;
  198.     IF ¬ GENERATINGCFM THEN
  199.         Macro
  200.         _LMGetTheZone         &dest=(sp)
  201.         move.l               $0118,&dest
  202.         EndM
  203.     ELSE
  204.         IMPORT_CFM_FUNCTION    LMGetTheZone
  205.     ENDIF
  206.  
  207. ;
  208. ; pascal void LMSetTheZone(THz value)
  209. ;
  210.     IF ¬ GENERATINGCFM THEN
  211.         Macro
  212.         _LMSetTheZone         &src=(sp)+
  213.         move.l               &src,$0118
  214.         EndM
  215.     ELSE
  216.         IMPORT_CFM_FUNCTION    LMSetTheZone
  217.     ENDIF
  218.  
  219. ;
  220. ; pascal Ptr LMGetUTableBase(void)
  221. ;
  222.     IF ¬ GENERATINGCFM THEN
  223.         Macro
  224.         _LMGetUTableBase         &dest=(sp)
  225.         move.l               $011C,&dest
  226.         EndM
  227.     ELSE
  228.         IMPORT_CFM_FUNCTION    LMGetUTableBase
  229.     ENDIF
  230.  
  231. ;
  232. ; pascal void LMSetUTableBase(Ptr value)
  233. ;
  234.     IF ¬ GENERATINGCFM THEN
  235.         Macro
  236.         _LMSetUTableBase         &src=(sp)+
  237.         move.l               &src,$011C
  238.         EndM
  239.     ELSE
  240.         IMPORT_CFM_FUNCTION    LMSetUTableBase
  241.     ENDIF
  242.  
  243. ;
  244. ; pascal UInt8 LMGetCPUFlag(void)
  245. ;
  246.     IF ¬ GENERATINGCFM THEN
  247.         Macro
  248.         _LMGetCPUFlag         &dest=(sp)
  249.         move.b               $012F,&dest
  250.         EndM
  251.     ELSE
  252.         IMPORT_CFM_FUNCTION    LMGetCPUFlag
  253.     ENDIF
  254.  
  255. ;
  256. ; pascal void LMSetCPUFlag(UInt8 value)
  257. ;
  258.     IF ¬ GENERATINGCFM THEN
  259.         Macro
  260.         _LMSetCPUFlag         &src=(sp)+
  261.         move.b               &src,$012F
  262.         EndM
  263.     ELSE
  264.         IMPORT_CFM_FUNCTION    LMSetCPUFlag
  265.     ENDIF
  266.  
  267. ;
  268. ; pascal Ptr LMGetApplLimit(void)
  269. ;
  270.     IF ¬ GENERATINGCFM THEN
  271.         Macro
  272.         _LMGetApplLimit         &dest=(sp)
  273.         move.l               $0130,&dest
  274.         EndM
  275.     ELSE
  276.         IMPORT_CFM_FUNCTION    LMGetApplLimit
  277.     ENDIF
  278.  
  279. ;
  280. ; pascal void LMSetApplLimit(Ptr value)
  281. ;
  282.     IF ¬ GENERATINGCFM THEN
  283.         Macro
  284.         _LMSetApplLimit         &src=(sp)+
  285.         move.l               &src,$0130
  286.         EndM
  287.     ELSE
  288.         IMPORT_CFM_FUNCTION    LMSetApplLimit
  289.     ENDIF
  290.  
  291. ;
  292. ; pascal SInt16 LMGetSysEvtMask(void)
  293. ;
  294.     IF ¬ GENERATINGCFM THEN
  295.         Macro
  296.         _LMGetSysEvtMask         &dest=(sp)
  297.         move.w               $0144,&dest
  298.         EndM
  299.     ELSE
  300.         IMPORT_CFM_FUNCTION    LMGetSysEvtMask
  301.     ENDIF
  302.  
  303. ;
  304. ; pascal void LMSetSysEvtMask(SInt16 value)
  305. ;
  306.     IF ¬ GENERATINGCFM THEN
  307.         Macro
  308.         _LMSetSysEvtMask         &src=(sp)+
  309.         move.w               &src,$0144
  310.         EndM
  311.     ELSE
  312.         IMPORT_CFM_FUNCTION    LMSetSysEvtMask
  313.     ENDIF
  314.  
  315. ;
  316. ; pascal SInt32 LMGetRndSeed(void)
  317. ;
  318.     IF ¬ GENERATINGCFM THEN
  319.         Macro
  320.         _LMGetRndSeed         &dest=(sp)
  321.         move.l               $0156,&dest
  322.         EndM
  323.     ELSE
  324.         IMPORT_CFM_FUNCTION    LMGetRndSeed
  325.     ENDIF
  326.  
  327. ;
  328. ; pascal void LMSetRndSeed(SInt32 value)
  329. ;
  330.     IF ¬ GENERATINGCFM THEN
  331.         Macro
  332.         _LMSetRndSeed         &src=(sp)+
  333.         move.l               &src,$0156
  334.         EndM
  335.     ELSE
  336.         IMPORT_CFM_FUNCTION    LMSetRndSeed
  337.     ENDIF
  338.  
  339. ;
  340. ; pascal UInt8 LMGetSEvtEnb(void)
  341. ;
  342.     IF ¬ GENERATINGCFM THEN
  343.         Macro
  344.         _LMGetSEvtEnb         &dest=(sp)
  345.         move.b               $015C,&dest
  346.         EndM
  347.     ELSE
  348.         IMPORT_CFM_FUNCTION    LMGetSEvtEnb
  349.     ENDIF
  350.  
  351. ;
  352. ; pascal void LMSetSEvtEnb(UInt8 value)
  353. ;
  354.     IF ¬ GENERATINGCFM THEN
  355.         Macro
  356.         _LMSetSEvtEnb         &src=(sp)+
  357.         move.b               &src,$015C
  358.         EndM
  359.     ELSE
  360.         IMPORT_CFM_FUNCTION    LMSetSEvtEnb
  361.     ENDIF
  362.  
  363. ;
  364. ; pascal SInt32 LMGetTicks(void)
  365. ;
  366.     IF ¬ GENERATINGCFM THEN
  367.         Macro
  368.         _LMGetTicks         &dest=(sp)
  369.         move.l               $016A,&dest
  370.         EndM
  371.     ELSE
  372.         IMPORT_CFM_FUNCTION    LMGetTicks
  373.     ENDIF
  374.  
  375. ;
  376. ; pascal void LMSetTicks(SInt32 value)
  377. ;
  378.     IF ¬ GENERATINGCFM THEN
  379.         Macro
  380.         _LMSetTicks         &src=(sp)+
  381.         move.l               &src,$016A
  382.         EndM
  383.     ELSE
  384.         IMPORT_CFM_FUNCTION    LMSetTicks
  385.     ENDIF
  386.  
  387. ;
  388. ; pascal SInt16 LMGetKeyThresh(void)
  389. ;
  390.     IF ¬ GENERATINGCFM THEN
  391.         Macro
  392.         _LMGetKeyThresh         &dest=(sp)
  393.         move.w               $018E,&dest
  394.         EndM
  395.     ELSE
  396.         IMPORT_CFM_FUNCTION    LMGetKeyThresh
  397.     ENDIF
  398.  
  399. ;
  400. ; pascal void LMSetKeyThresh(SInt16 value)
  401. ;
  402.     IF ¬ GENERATINGCFM THEN
  403.         Macro
  404.         _LMSetKeyThresh         &src=(sp)+
  405.         move.w               &src,$018E
  406.         EndM
  407.     ELSE
  408.         IMPORT_CFM_FUNCTION    LMSetKeyThresh
  409.     ENDIF
  410.  
  411. ;
  412. ; pascal SInt16 LMGetKeyRepThresh(void)
  413. ;
  414.     IF ¬ GENERATINGCFM THEN
  415.         Macro
  416.         _LMGetKeyRepThresh         &dest=(sp)
  417.         move.w               $0190,&dest
  418.         EndM
  419.     ELSE
  420.         IMPORT_CFM_FUNCTION    LMGetKeyRepThresh
  421.     ENDIF
  422.  
  423. ;
  424. ; pascal void LMSetKeyRepThresh(SInt16 value)
  425. ;
  426.     IF ¬ GENERATINGCFM THEN
  427.         Macro
  428.         _LMSetKeyRepThresh         &src=(sp)+
  429.         move.w               &src,$0190
  430.         EndM
  431.     ELSE
  432.         IMPORT_CFM_FUNCTION    LMSetKeyRepThresh
  433.     ENDIF
  434.  
  435. ;
  436. ; pascal SInt16 LMGetUnitTableEntryCount(void)
  437. ;
  438.     IF ¬ GENERATINGCFM THEN
  439.         Macro
  440.         _LMGetUnitTableEntryCount         &dest=(sp)
  441.         move.w               $01D2,&dest
  442.         EndM
  443.     ELSE
  444.         IMPORT_CFM_FUNCTION    LMGetUnitTableEntryCount
  445.     ENDIF
  446.  
  447. ;
  448. ; pascal void LMSetUnitTableEntryCount(SInt16 value)
  449. ;
  450.     IF ¬ GENERATINGCFM THEN
  451.         Macro
  452.         _LMSetUnitTableEntryCount         &src=(sp)+
  453.         move.w               &src,$01D2
  454.         EndM
  455.     ELSE
  456.         IMPORT_CFM_FUNCTION    LMSetUnitTableEntryCount
  457.     ENDIF
  458.  
  459. ;
  460. ; pascal Ptr LMGetVIA(void)
  461. ;
  462.     IF ¬ GENERATINGCFM THEN
  463.         Macro
  464.         _LMGetVIA         &dest=(sp)
  465.         move.l               $01D4,&dest
  466.         EndM
  467.     ELSE
  468.         IMPORT_CFM_FUNCTION    LMGetVIA
  469.     ENDIF
  470.  
  471. ;
  472. ; pascal void LMSetVIA(Ptr value)
  473. ;
  474.     IF ¬ GENERATINGCFM THEN
  475.         Macro
  476.         _LMSetVIA         &src=(sp)+
  477.         move.l               &src,$01D4
  478.         EndM
  479.     ELSE
  480.         IMPORT_CFM_FUNCTION    LMSetVIA
  481.     ENDIF
  482.  
  483. ;
  484. ; pascal Ptr LMGetSCCRd(void)
  485. ;
  486.     IF ¬ GENERATINGCFM THEN
  487.         Macro
  488.         _LMGetSCCRd         &dest=(sp)
  489.         move.l               $01D8,&dest
  490.         EndM
  491.     ELSE
  492.         IMPORT_CFM_FUNCTION    LMGetSCCRd
  493.     ENDIF
  494.  
  495. ;
  496. ; pascal void LMSetSCCRd(Ptr value)
  497. ;
  498.     IF ¬ GENERATINGCFM THEN
  499.         Macro
  500.         _LMSetSCCRd         &src=(sp)+
  501.         move.l               &src,$01D8
  502.         EndM
  503.     ELSE
  504.         IMPORT_CFM_FUNCTION    LMSetSCCRd
  505.     ENDIF
  506.  
  507. ;
  508. ; pascal Ptr LMGetSCCWr(void)
  509. ;
  510.     IF ¬ GENERATINGCFM THEN
  511.         Macro
  512.         _LMGetSCCWr         &dest=(sp)
  513.         move.l               $01DC,&dest
  514.         EndM
  515.     ELSE
  516.         IMPORT_CFM_FUNCTION    LMGetSCCWr
  517.     ENDIF
  518.  
  519. ;
  520. ; pascal void LMSetSCCWr(Ptr value)
  521. ;
  522.     IF ¬ GENERATINGCFM THEN
  523.         Macro
  524.         _LMSetSCCWr         &src=(sp)+
  525.         move.l               &src,$01DC
  526.         EndM
  527.     ELSE
  528.         IMPORT_CFM_FUNCTION    LMSetSCCWr
  529.     ENDIF
  530.  
  531. ;
  532. ; pascal UInt8 LMGetSPValid(void)
  533. ;
  534.     IF ¬ GENERATINGCFM THEN
  535.         Macro
  536.         _LMGetSPValid         &dest=(sp)
  537.         move.b               $01F8,&dest
  538.         EndM
  539.     ELSE
  540.         IMPORT_CFM_FUNCTION    LMGetSPValid
  541.     ENDIF
  542.  
  543. ;
  544. ; pascal void LMSetSPValid(UInt8 value)
  545. ;
  546.     IF ¬ GENERATINGCFM THEN
  547.         Macro
  548.         _LMSetSPValid         &src=(sp)+
  549.         move.b               &src,$01F8
  550.         EndM
  551.     ELSE
  552.         IMPORT_CFM_FUNCTION    LMSetSPValid
  553.     ENDIF
  554.  
  555. ;
  556. ; pascal UInt8 LMGetSPATalkA(void)
  557. ;
  558.     IF ¬ GENERATINGCFM THEN
  559.         Macro
  560.         _LMGetSPATalkA         &dest=(sp)
  561.         move.b               $01F9,&dest
  562.         EndM
  563.     ELSE
  564.         IMPORT_CFM_FUNCTION    LMGetSPATalkA
  565.     ENDIF
  566.  
  567. ;
  568. ; pascal void LMSetSPATalkA(UInt8 value)
  569. ;
  570.     IF ¬ GENERATINGCFM THEN
  571.         Macro
  572.         _LMSetSPATalkA         &src=(sp)+
  573.         move.b               &src,$01F9
  574.         EndM
  575.     ELSE
  576.         IMPORT_CFM_FUNCTION    LMSetSPATalkA
  577.     ENDIF
  578.  
  579. ;
  580. ; pascal UInt8 LMGetSPATalkB(void)
  581. ;
  582.     IF ¬ GENERATINGCFM THEN
  583.         Macro
  584.         _LMGetSPATalkB         &dest=(sp)
  585.         move.b               $01FA,&dest
  586.         EndM
  587.     ELSE
  588.         IMPORT_CFM_FUNCTION    LMGetSPATalkB
  589.     ENDIF
  590.  
  591. ;
  592. ; pascal void LMSetSPATalkB(UInt8 value)
  593. ;
  594.     IF ¬ GENERATINGCFM THEN
  595.         Macro
  596.         _LMSetSPATalkB         &src=(sp)+
  597.         move.b               &src,$01FA
  598.         EndM
  599.     ELSE
  600.         IMPORT_CFM_FUNCTION    LMSetSPATalkB
  601.     ENDIF
  602.  
  603. ;
  604. ; pascal UInt8 LMGetSPConfig(void)
  605. ;
  606.     IF ¬ GENERATINGCFM THEN
  607.         Macro
  608.         _LMGetSPConfig         &dest=(sp)
  609.         move.b               $01FB,&dest
  610.         EndM
  611.     ELSE
  612.         IMPORT_CFM_FUNCTION    LMGetSPConfig
  613.     ENDIF
  614.  
  615. ;
  616. ; pascal void LMSetSPConfig(UInt8 value)
  617. ;
  618.     IF ¬ GENERATINGCFM THEN
  619.         Macro
  620.         _LMSetSPConfig         &src=(sp)+
  621.         move.b               &src,$01FB
  622.         EndM
  623.     ELSE
  624.         IMPORT_CFM_FUNCTION    LMSetSPConfig
  625.     ENDIF
  626.  
  627. ;
  628. ; pascal SInt16 LMGetSPPortA(void)
  629. ;
  630.     IF ¬ GENERATINGCFM THEN
  631.         Macro
  632.         _LMGetSPPortA         &dest=(sp)
  633.         move.w               $01FC,&dest
  634.         EndM
  635.     ELSE
  636.         IMPORT_CFM_FUNCTION    LMGetSPPortA
  637.     ENDIF
  638.  
  639. ;
  640. ; pascal void LMSetSPPortA(SInt16 value)
  641. ;
  642.     IF ¬ GENERATINGCFM THEN
  643.         Macro
  644.         _LMSetSPPortA         &src=(sp)+
  645.         move.w               &src,$01FC
  646.         EndM
  647.     ELSE
  648.         IMPORT_CFM_FUNCTION    LMSetSPPortA
  649.     ENDIF
  650.  
  651. ;
  652. ; pascal SInt16 LMGetSPPortB(void)
  653. ;
  654.     IF ¬ GENERATINGCFM THEN
  655.         Macro
  656.         _LMGetSPPortB         &dest=(sp)
  657.         move.w               $01FE,&dest
  658.         EndM
  659.     ELSE
  660.         IMPORT_CFM_FUNCTION    LMGetSPPortB
  661.     ENDIF
  662.  
  663. ;
  664. ; pascal void LMSetSPPortB(SInt16 value)
  665. ;
  666.     IF ¬ GENERATINGCFM THEN
  667.         Macro
  668.         _LMSetSPPortB         &src=(sp)+
  669.         move.w               &src,$01FE
  670.         EndM
  671.     ELSE
  672.         IMPORT_CFM_FUNCTION    LMSetSPPortB
  673.     ENDIF
  674.  
  675. ;
  676. ; pascal SInt32 LMGetSPAlarm(void)
  677. ;
  678.     IF ¬ GENERATINGCFM THEN
  679.         Macro
  680.         _LMGetSPAlarm         &dest=(sp)
  681.         move.l               $0200,&dest
  682.         EndM
  683.     ELSE
  684.         IMPORT_CFM_FUNCTION    LMGetSPAlarm
  685.     ENDIF
  686.  
  687. ;
  688. ; pascal void LMSetSPAlarm(SInt32 value)
  689. ;
  690.     IF ¬ GENERATINGCFM THEN
  691.         Macro
  692.         _LMSetSPAlarm         &src=(sp)+
  693.         move.l               &src,$0200
  694.         EndM
  695.     ELSE
  696.         IMPORT_CFM_FUNCTION    LMSetSPAlarm
  697.     ENDIF
  698.  
  699. ;
  700. ; pascal SInt16 LMGetSPFont(void)
  701. ;
  702.     IF ¬ GENERATINGCFM THEN
  703.         Macro
  704.         _LMGetSPFont         &dest=(sp)
  705.         move.w               $0204,&dest
  706.         EndM
  707.     ELSE
  708.         IMPORT_CFM_FUNCTION    LMGetSPFont
  709.     ENDIF
  710.  
  711. ;
  712. ; pascal void LMSetSPFont(SInt16 value)
  713. ;
  714.     IF ¬ GENERATINGCFM THEN
  715.         Macro
  716.         _LMSetSPFont         &src=(sp)+
  717.         move.w               &src,$0204
  718.         EndM
  719.     ELSE
  720.         IMPORT_CFM_FUNCTION    LMSetSPFont
  721.     ENDIF
  722.  
  723. ;
  724. ; pascal UInt8 LMGetSPKbd(void)
  725. ;
  726.     IF ¬ GENERATINGCFM THEN
  727.         Macro
  728.         _LMGetSPKbd         &dest=(sp)
  729.         move.b               $0206,&dest
  730.         EndM
  731.     ELSE
  732.         IMPORT_CFM_FUNCTION    LMGetSPKbd
  733.     ENDIF
  734.  
  735. ;
  736. ; pascal void LMSetSPKbd(UInt8 value)
  737. ;
  738.     IF ¬ GENERATINGCFM THEN
  739.         Macro
  740.         _LMSetSPKbd         &src=(sp)+
  741.         move.b               &src,$0206
  742.         EndM
  743.     ELSE
  744.         IMPORT_CFM_FUNCTION    LMSetSPKbd
  745.     ENDIF
  746.  
  747. ;
  748. ; pascal UInt8 LMGetSPPrint(void)
  749. ;
  750.     IF ¬ GENERATINGCFM THEN
  751.         Macro
  752.         _LMGetSPPrint         &dest=(sp)
  753.         move.b               $0207,&dest
  754.         EndM
  755.     ELSE
  756.         IMPORT_CFM_FUNCTION    LMGetSPPrint
  757.     ENDIF
  758.  
  759. ;
  760. ; pascal void LMSetSPPrint(UInt8 value)
  761. ;
  762.     IF ¬ GENERATINGCFM THEN
  763.         Macro
  764.         _LMSetSPPrint         &src=(sp)+
  765.         move.b               &src,$0207
  766.         EndM
  767.     ELSE
  768.         IMPORT_CFM_FUNCTION    LMSetSPPrint
  769.     ENDIF
  770.  
  771. ;
  772. ; pascal UInt8 LMGetSPVolCtl(void)
  773. ;
  774.     IF ¬ GENERATINGCFM THEN
  775.         Macro
  776.         _LMGetSPVolCtl         &dest=(sp)
  777.         move.b               $0208,&dest
  778.         EndM
  779.     ELSE
  780.         IMPORT_CFM_FUNCTION    LMGetSPVolCtl
  781.     ENDIF
  782.  
  783. ;
  784. ; pascal void LMSetSPVolCtl(UInt8 value)
  785. ;
  786.     IF ¬ GENERATINGCFM THEN
  787.         Macro
  788.         _LMSetSPVolCtl         &src=(sp)+
  789.         move.b               &src,$0208
  790.         EndM
  791.     ELSE
  792.         IMPORT_CFM_FUNCTION    LMSetSPVolCtl
  793.     ENDIF
  794.  
  795. ;
  796. ; pascal UInt8 LMGetSPClikCaret(void)
  797. ;
  798.     IF ¬ GENERATINGCFM THEN
  799.         Macro
  800.         _LMGetSPClikCaret         &dest=(sp)
  801.         move.b               $0209,&dest
  802.         EndM
  803.     ELSE
  804.         IMPORT_CFM_FUNCTION    LMGetSPClikCaret
  805.     ENDIF
  806.  
  807. ;
  808. ; pascal void LMSetSPClikCaret(UInt8 value)
  809. ;
  810.     IF ¬ GENERATINGCFM THEN
  811.         Macro
  812.         _LMSetSPClikCaret         &src=(sp)+
  813.         move.b               &src,$0209
  814.         EndM
  815.     ELSE
  816.         IMPORT_CFM_FUNCTION    LMSetSPClikCaret
  817.     ENDIF
  818.  
  819. ;
  820. ; pascal UInt8 LMGetSPMisc2(void)
  821. ;
  822.     IF ¬ GENERATINGCFM THEN
  823.         Macro
  824.         _LMGetSPMisc2         &dest=(sp)
  825.         move.b               $020B,&dest
  826.         EndM
  827.     ELSE
  828.         IMPORT_CFM_FUNCTION    LMGetSPMisc2
  829.     ENDIF
  830.  
  831. ;
  832. ; pascal void LMSetSPMisc2(UInt8 value)
  833. ;
  834.     IF ¬ GENERATINGCFM THEN
  835.         Macro
  836.         _LMSetSPMisc2         &src=(sp)+
  837.         move.b               &src,$020B
  838.         EndM
  839.     ELSE
  840.         IMPORT_CFM_FUNCTION    LMSetSPMisc2
  841.     ENDIF
  842.  
  843. ;
  844. ; pascal SInt32 LMGetTime(void)
  845. ;
  846.     IF ¬ GENERATINGCFM THEN
  847.         Macro
  848.         _LMGetTime         &dest=(sp)
  849.         move.l               $020C,&dest
  850.         EndM
  851.     ELSE
  852.         IMPORT_CFM_FUNCTION    LMGetTime
  853.     ENDIF
  854.  
  855. ;
  856. ; pascal void LMSetTime(SInt32 value)
  857. ;
  858.     IF ¬ GENERATINGCFM THEN
  859.         Macro
  860.         _LMSetTime         &src=(sp)+
  861.         move.l               &src,$020C
  862.         EndM
  863.     ELSE
  864.         IMPORT_CFM_FUNCTION    LMSetTime
  865.     ENDIF
  866.  
  867. ;
  868. ; pascal SInt16 LMGetBootDrive(void)
  869. ;
  870.     IF ¬ GENERATINGCFM THEN
  871.         Macro
  872.         _LMGetBootDrive         &dest=(sp)
  873.         move.w               $0210,&dest
  874.         EndM
  875.     ELSE
  876.         IMPORT_CFM_FUNCTION    LMGetBootDrive
  877.     ENDIF
  878.  
  879. ;
  880. ; pascal void LMSetBootDrive(SInt16 value)
  881. ;
  882.     IF ¬ GENERATINGCFM THEN
  883.         Macro
  884.         _LMSetBootDrive         &src=(sp)+
  885.         move.w               &src,$0210
  886.         EndM
  887.     ELSE
  888.         IMPORT_CFM_FUNCTION    LMSetBootDrive
  889.     ENDIF
  890.  
  891. ;
  892. ; pascal SInt16 LMGetSFSaveDisk(void)
  893. ;
  894.     IF ¬ GENERATINGCFM THEN
  895.         Macro
  896.         _LMGetSFSaveDisk         &dest=(sp)
  897.         move.w               $0214,&dest
  898.         EndM
  899.     ELSE
  900.         IMPORT_CFM_FUNCTION    LMGetSFSaveDisk
  901.     ENDIF
  902.  
  903. ;
  904. ; pascal void LMSetSFSaveDisk(SInt16 value)
  905. ;
  906.     IF ¬ GENERATINGCFM THEN
  907.         Macro
  908.         _LMSetSFSaveDisk         &src=(sp)+
  909.         move.w               &src,$0214
  910.         EndM
  911.     ELSE
  912.         IMPORT_CFM_FUNCTION    LMSetSFSaveDisk
  913.     ENDIF
  914.  
  915. ;
  916. ; pascal UInt8 LMGetKbdLast(void)
  917. ;
  918.     IF ¬ GENERATINGCFM THEN
  919.         Macro
  920.         _LMGetKbdLast         &dest=(sp)
  921.         move.b               $0218,&dest
  922.         EndM
  923.     ELSE
  924.         IMPORT_CFM_FUNCTION    LMGetKbdLast
  925.     ENDIF
  926.  
  927. ;
  928. ; pascal void LMSetKbdLast(UInt8 value)
  929. ;
  930.     IF ¬ GENERATINGCFM THEN
  931.         Macro
  932.         _LMSetKbdLast         &src=(sp)+
  933.         move.b               &src,$0218
  934.         EndM
  935.     ELSE
  936.         IMPORT_CFM_FUNCTION    LMSetKbdLast
  937.     ENDIF
  938.  
  939. ;
  940. ; pascal UInt8 LMGetKbdType(void)
  941. ;
  942.     IF ¬ GENERATINGCFM THEN
  943.         Macro
  944.         _LMGetKbdType         &dest=(sp)
  945.         move.b               $021E,&dest
  946.         EndM
  947.     ELSE
  948.         IMPORT_CFM_FUNCTION    LMGetKbdType
  949.     ENDIF
  950.  
  951. ;
  952. ; pascal void LMSetKbdType(UInt8 value)
  953. ;
  954.     IF ¬ GENERATINGCFM THEN
  955.         Macro
  956.         _LMSetKbdType         &src=(sp)+
  957.         move.b               &src,$021E
  958.         EndM
  959.     ELSE
  960.         IMPORT_CFM_FUNCTION    LMSetKbdType
  961.     ENDIF
  962.  
  963. ;
  964. ; pascal SInt16 LMGetMemErr(void)
  965. ;
  966.     IF ¬ GENERATINGCFM THEN
  967.         Macro
  968.         _LMGetMemErr         &dest=(sp)
  969.         move.w               $0220,&dest
  970.         EndM
  971.     ELSE
  972.         IMPORT_CFM_FUNCTION    LMGetMemErr
  973.     ENDIF
  974.  
  975. ;
  976. ; pascal void LMSetMemErr(SInt16 value)
  977. ;
  978.     IF ¬ GENERATINGCFM THEN
  979.         Macro
  980.         _LMSetMemErr         &src=(sp)+
  981.         move.w               &src,$0220
  982.         EndM
  983.     ELSE
  984.         IMPORT_CFM_FUNCTION    LMSetMemErr
  985.     ENDIF
  986.  
  987. ;
  988. ; pascal UInt8 LMGetSdVolume(void)
  989. ;
  990.     IF ¬ GENERATINGCFM THEN
  991.         Macro
  992.         _LMGetSdVolume         &dest=(sp)
  993.         move.b               $0260,&dest
  994.         EndM
  995.     ELSE
  996.         IMPORT_CFM_FUNCTION    LMGetSdVolume
  997.     ENDIF
  998.  
  999. ;
  1000. ; pascal void LMSetSdVolume(UInt8 value)
  1001. ;
  1002.     IF ¬ GENERATINGCFM THEN
  1003.         Macro
  1004.         _LMSetSdVolume         &src=(sp)+
  1005.         move.b               &src,$0260
  1006.         EndM
  1007.     ELSE
  1008.         IMPORT_CFM_FUNCTION    LMSetSdVolume
  1009.     ENDIF
  1010.  
  1011. ;
  1012. ; pascal Ptr LMGetSoundPtr(void)
  1013. ;
  1014.     IF ¬ GENERATINGCFM THEN
  1015.         Macro
  1016.         _LMGetSoundPtr         &dest=(sp)
  1017.         move.l               $0262,&dest
  1018.         EndM
  1019.     ELSE
  1020.         IMPORT_CFM_FUNCTION    LMGetSoundPtr
  1021.     ENDIF
  1022.  
  1023. ;
  1024. ; pascal void LMSetSoundPtr(Ptr value)
  1025. ;
  1026.     IF ¬ GENERATINGCFM THEN
  1027.         Macro
  1028.         _LMSetSoundPtr         &src=(sp)+
  1029.         move.l               &src,$0262
  1030.         EndM
  1031.     ELSE
  1032.         IMPORT_CFM_FUNCTION    LMSetSoundPtr
  1033.     ENDIF
  1034.  
  1035. ;
  1036. ; pascal Ptr LMGetSoundBase(void)
  1037. ;
  1038.     IF ¬ GENERATINGCFM THEN
  1039.         Macro
  1040.         _LMGetSoundBase         &dest=(sp)
  1041.         move.l               $0266,&dest
  1042.         EndM
  1043.     ELSE
  1044.         IMPORT_CFM_FUNCTION    LMGetSoundBase
  1045.     ENDIF
  1046.  
  1047. ;
  1048. ; pascal void LMSetSoundBase(Ptr value)
  1049. ;
  1050.     IF ¬ GENERATINGCFM THEN
  1051.         Macro
  1052.         _LMSetSoundBase         &src=(sp)+
  1053.         move.l               &src,$0266
  1054.         EndM
  1055.     ELSE
  1056.         IMPORT_CFM_FUNCTION    LMSetSoundBase
  1057.     ENDIF
  1058.  
  1059. ;
  1060. ; pascal UInt8 LMGetSoundLevel(void)
  1061. ;
  1062.     IF ¬ GENERATINGCFM THEN
  1063.         Macro
  1064.         _LMGetSoundLevel         &dest=(sp)
  1065.         move.b               $027F,&dest
  1066.         EndM
  1067.     ELSE
  1068.         IMPORT_CFM_FUNCTION    LMGetSoundLevel
  1069.     ENDIF
  1070.  
  1071. ;
  1072. ; pascal void LMSetSoundLevel(UInt8 value)
  1073. ;
  1074.     IF ¬ GENERATINGCFM THEN
  1075.         Macro
  1076.         _LMSetSoundLevel         &src=(sp)+
  1077.         move.b               &src,$027F
  1078.         EndM
  1079.     ELSE
  1080.         IMPORT_CFM_FUNCTION    LMSetSoundLevel
  1081.     ENDIF
  1082.  
  1083. ;
  1084. ; pascal SInt16 LMGetCurPitch(void)
  1085. ;
  1086.     IF ¬ GENERATINGCFM THEN
  1087.         Macro
  1088.         _LMGetCurPitch         &dest=(sp)
  1089.         move.w               $0280,&dest
  1090.         EndM
  1091.     ELSE
  1092.         IMPORT_CFM_FUNCTION    LMGetCurPitch
  1093.     ENDIF
  1094.  
  1095. ;
  1096. ; pascal void LMSetCurPitch(SInt16 value)
  1097. ;
  1098.     IF ¬ GENERATINGCFM THEN
  1099.         Macro
  1100.         _LMSetCurPitch         &src=(sp)+
  1101.         move.w               &src,$0280
  1102.         EndM
  1103.     ELSE
  1104.         IMPORT_CFM_FUNCTION    LMSetCurPitch
  1105.     ENDIF
  1106.  
  1107. ;
  1108. ; pascal SInt16 LMGetROM85(void)
  1109. ;
  1110.     IF ¬ GENERATINGCFM THEN
  1111.         Macro
  1112.         _LMGetROM85         &dest=(sp)
  1113.         move.w               $028E,&dest
  1114.         EndM
  1115.     ELSE
  1116.         IMPORT_CFM_FUNCTION    LMGetROM85
  1117.     ENDIF
  1118.  
  1119. ;
  1120. ; pascal void LMSetROM85(SInt16 value)
  1121. ;
  1122.     IF ¬ GENERATINGCFM THEN
  1123.         Macro
  1124.         _LMSetROM85         &src=(sp)+
  1125.         move.w               &src,$028E
  1126.         EndM
  1127.     ELSE
  1128.         IMPORT_CFM_FUNCTION    LMSetROM85
  1129.     ENDIF
  1130.  
  1131. ;
  1132. ; pascal UInt8 LMGetPortBUse(void)
  1133. ;
  1134.     IF ¬ GENERATINGCFM THEN
  1135.         Macro
  1136.         _LMGetPortBUse         &dest=(sp)
  1137.         move.b               $0291,&dest
  1138.         EndM
  1139.     ELSE
  1140.         IMPORT_CFM_FUNCTION    LMGetPortBUse
  1141.     ENDIF
  1142.  
  1143. ;
  1144. ; pascal void LMSetPortBUse(UInt8 value)
  1145. ;
  1146.     IF ¬ GENERATINGCFM THEN
  1147.         Macro
  1148.         _LMSetPortBUse         &src=(sp)+
  1149.         move.b               &src,$0291
  1150.         EndM
  1151.     ELSE
  1152.         IMPORT_CFM_FUNCTION    LMSetPortBUse
  1153.     ENDIF
  1154.  
  1155. ;
  1156. ; pascal GNEFilterUPP LMGetGNEFilter(void)
  1157. ;
  1158.     IF ¬ GENERATINGCFM THEN
  1159.         Macro
  1160.         _LMGetGNEFilter         &dest=(sp)
  1161.         move.l               $029A,&dest
  1162.         EndM
  1163.     ELSE
  1164.         IMPORT_CFM_FUNCTION    LMGetGNEFilter
  1165.     ENDIF
  1166.  
  1167. ;
  1168. ; pascal void LMSetGNEFilter(GNEFilterUPP value)
  1169. ;
  1170.     IF ¬ GENERATINGCFM THEN
  1171.         Macro
  1172.         _LMSetGNEFilter         &src=(sp)+
  1173.         move.l               &src,$029A
  1174.         EndM
  1175.     ELSE
  1176.         IMPORT_CFM_FUNCTION    LMSetGNEFilter
  1177.     ENDIF
  1178.  
  1179. ;
  1180. ; pascal THz LMGetSysZone(void)
  1181. ;
  1182.     IF ¬ GENERATINGCFM THEN
  1183.         Macro
  1184.         _LMGetSysZone         &dest=(sp)
  1185.         move.l               $02A6,&dest
  1186.         EndM
  1187.     ELSE
  1188.         IMPORT_CFM_FUNCTION    LMGetSysZone
  1189.     ENDIF
  1190.  
  1191. ;
  1192. ; pascal void LMSetSysZone(THz value)
  1193. ;
  1194.     IF ¬ GENERATINGCFM THEN
  1195.         Macro
  1196.         _LMSetSysZone         &src=(sp)+
  1197.         move.l               &src,$02A6
  1198.         EndM
  1199.     ELSE
  1200.         IMPORT_CFM_FUNCTION    LMSetSysZone
  1201.     ENDIF
  1202.  
  1203. ;
  1204. ; pascal THz LMGetApplZone(void)
  1205. ;
  1206.     IF ¬ GENERATINGCFM THEN
  1207.         Macro
  1208.         _LMGetApplZone         &dest=(sp)
  1209.         move.l               $02AA,&dest
  1210.         EndM
  1211.     ELSE
  1212.         IMPORT_CFM_FUNCTION    LMGetApplZone
  1213.     ENDIF
  1214.  
  1215. ;
  1216. ; pascal void LMSetApplZone(THz value)
  1217. ;
  1218.     IF ¬ GENERATINGCFM THEN
  1219.         Macro
  1220.         _LMSetApplZone         &src=(sp)+
  1221.         move.l               &src,$02AA
  1222.         EndM
  1223.     ELSE
  1224.         IMPORT_CFM_FUNCTION    LMSetApplZone
  1225.     ENDIF
  1226.  
  1227. ;
  1228. ; pascal Ptr LMGetROMBase(void)
  1229. ;
  1230.     IF ¬ GENERATINGCFM THEN
  1231.         Macro
  1232.         _LMGetROMBase         &dest=(sp)
  1233.         move.l               $02AE,&dest
  1234.         EndM
  1235.     ELSE
  1236.         IMPORT_CFM_FUNCTION    LMGetROMBase
  1237.     ENDIF
  1238.  
  1239. ;
  1240. ; pascal void LMSetROMBase(Ptr value)
  1241. ;
  1242.     IF ¬ GENERATINGCFM THEN
  1243.         Macro
  1244.         _LMSetROMBase         &src=(sp)+
  1245.         move.l               &src,$02AE
  1246.         EndM
  1247.     ELSE
  1248.         IMPORT_CFM_FUNCTION    LMSetROMBase
  1249.     ENDIF
  1250.  
  1251. ;
  1252. ; pascal Ptr LMGetRAMBase(void)
  1253. ;
  1254.     IF ¬ GENERATINGCFM THEN
  1255.         Macro
  1256.         _LMGetRAMBase         &dest=(sp)
  1257.         move.l               $02B2,&dest
  1258.         EndM
  1259.     ELSE
  1260.         IMPORT_CFM_FUNCTION    LMGetRAMBase
  1261.     ENDIF
  1262.  
  1263. ;
  1264. ; pascal void LMSetRAMBase(Ptr value)
  1265. ;
  1266.     IF ¬ GENERATINGCFM THEN
  1267.         Macro
  1268.         _LMSetRAMBase         &src=(sp)+
  1269.         move.l               &src,$02B2
  1270.         EndM
  1271.     ELSE
  1272.         IMPORT_CFM_FUNCTION    LMSetRAMBase
  1273.     ENDIF
  1274.  
  1275. ;
  1276. ; pascal Ptr LMGetDSAlertTab(void)
  1277. ;
  1278.     IF ¬ GENERATINGCFM THEN
  1279.         Macro
  1280.         _LMGetDSAlertTab         &dest=(sp)
  1281.         move.l               $02BA,&dest
  1282.         EndM
  1283.     ELSE
  1284.         IMPORT_CFM_FUNCTION    LMGetDSAlertTab
  1285.     ENDIF
  1286.  
  1287. ;
  1288. ; pascal void LMSetDSAlertTab(Ptr value)
  1289. ;
  1290.     IF ¬ GENERATINGCFM THEN
  1291.         Macro
  1292.         _LMSetDSAlertTab         &src=(sp)+
  1293.         move.l               &src,$02BA
  1294.         EndM
  1295.     ELSE
  1296.         IMPORT_CFM_FUNCTION    LMSetDSAlertTab
  1297.     ENDIF
  1298.  
  1299. ;
  1300. ; pascal Ptr LMGetABusVars(void)
  1301. ;
  1302.     IF ¬ GENERATINGCFM THEN
  1303.         Macro
  1304.         _LMGetABusVars         &dest=(sp)
  1305.         move.l               $02D8,&dest
  1306.         EndM
  1307.     ELSE
  1308.         IMPORT_CFM_FUNCTION    LMGetABusVars
  1309.     ENDIF
  1310.  
  1311. ;
  1312. ; pascal void LMSetABusVars(Ptr value)
  1313. ;
  1314.     IF ¬ GENERATINGCFM THEN
  1315.         Macro
  1316.         _LMSetABusVars         &src=(sp)+
  1317.         move.l               &src,$02D8
  1318.         EndM
  1319.     ELSE
  1320.         IMPORT_CFM_FUNCTION    LMSetABusVars
  1321.     ENDIF
  1322.  
  1323. ;
  1324. ; pascal Ptr LMGetABusDCE(void)
  1325. ;
  1326.     IF ¬ GENERATINGCFM THEN
  1327.         Macro
  1328.         _LMGetABusDCE         &dest=(sp)
  1329.         move.l               $02DC,&dest
  1330.         EndM
  1331.     ELSE
  1332.         IMPORT_CFM_FUNCTION    LMGetABusDCE
  1333.     ENDIF
  1334.  
  1335. ;
  1336. ; pascal void LMSetABusDCE(Ptr value)
  1337. ;
  1338.     IF ¬ GENERATINGCFM THEN
  1339.         Macro
  1340.         _LMSetABusDCE         &src=(sp)+
  1341.         move.l               &src,$02DC
  1342.         EndM
  1343.     ELSE
  1344.         IMPORT_CFM_FUNCTION    LMSetABusDCE
  1345.     ENDIF
  1346.  
  1347. ;
  1348. ; pascal UInt32 LMGetDoubleTime(void)
  1349. ;
  1350.     IF ¬ GENERATINGCFM THEN
  1351.         Macro
  1352.         _LMGetDoubleTime         &dest=(sp)
  1353.         move.l               $02F0,&dest
  1354.         EndM
  1355.     ELSE
  1356.         IMPORT_CFM_FUNCTION    LMGetDoubleTime
  1357.     ENDIF
  1358.  
  1359. ;
  1360. ; pascal void LMSetDoubleTime(UInt32 value)
  1361. ;
  1362.     IF ¬ GENERATINGCFM THEN
  1363.         Macro
  1364.         _LMSetDoubleTime         &src=(sp)+
  1365.         move.l               &src,$02F0
  1366.         EndM
  1367.     ELSE
  1368.         IMPORT_CFM_FUNCTION    LMSetDoubleTime
  1369.     ENDIF
  1370.  
  1371. ;
  1372. ; pascal UInt32 LMGetCaretTime(void)
  1373. ;
  1374.     IF ¬ GENERATINGCFM THEN
  1375.         Macro
  1376.         _LMGetCaretTime         &dest=(sp)
  1377.         move.l               $02F4,&dest
  1378.         EndM
  1379.     ELSE
  1380.         IMPORT_CFM_FUNCTION    LMGetCaretTime
  1381.     ENDIF
  1382.  
  1383. ;
  1384. ; pascal void LMSetCaretTime(UInt32 value)
  1385. ;
  1386.     IF ¬ GENERATINGCFM THEN
  1387.         Macro
  1388.         _LMSetCaretTime         &src=(sp)+
  1389.         move.l               &src,$02F4
  1390.         EndM
  1391.     ELSE
  1392.         IMPORT_CFM_FUNCTION    LMSetCaretTime
  1393.     ENDIF
  1394.  
  1395. ;
  1396. ; pascal UInt8 LMGetScrDmpEnb(void)
  1397. ;
  1398.     IF ¬ GENERATINGCFM THEN
  1399.         Macro
  1400.         _LMGetScrDmpEnb         &dest=(sp)
  1401.         move.b               $02F8,&dest
  1402.         EndM
  1403.     ELSE
  1404.         IMPORT_CFM_FUNCTION    LMGetScrDmpEnb
  1405.     ENDIF
  1406.  
  1407. ;
  1408. ; pascal void LMSetScrDmpEnb(UInt8 value)
  1409. ;
  1410.     IF ¬ GENERATINGCFM THEN
  1411.         Macro
  1412.         _LMSetScrDmpEnb         &src=(sp)+
  1413.         move.b               &src,$02F8
  1414.         EndM
  1415.     ELSE
  1416.         IMPORT_CFM_FUNCTION    LMSetScrDmpEnb
  1417.     ENDIF
  1418.  
  1419. ;
  1420. ; pascal SInt32 LMGetBufTgFNum(void)
  1421. ;
  1422.     IF ¬ GENERATINGCFM THEN
  1423.         Macro
  1424.         _LMGetBufTgFNum         &dest=(sp)
  1425.         move.l               $02FC,&dest
  1426.         EndM
  1427.     ELSE
  1428.         IMPORT_CFM_FUNCTION    LMGetBufTgFNum
  1429.     ENDIF
  1430.  
  1431. ;
  1432. ; pascal void LMSetBufTgFNum(SInt32 value)
  1433. ;
  1434.     IF ¬ GENERATINGCFM THEN
  1435.         Macro
  1436.         _LMSetBufTgFNum         &src=(sp)+
  1437.         move.l               &src,$02FC
  1438.         EndM
  1439.     ELSE
  1440.         IMPORT_CFM_FUNCTION    LMSetBufTgFNum
  1441.     ENDIF
  1442.  
  1443. ;
  1444. ; pascal SInt16 LMGetBufTgFFlg(void)
  1445. ;
  1446.     IF ¬ GENERATINGCFM THEN
  1447.         Macro
  1448.         _LMGetBufTgFFlg         &dest=(sp)
  1449.         move.w               $0300,&dest
  1450.         EndM
  1451.     ELSE
  1452.         IMPORT_CFM_FUNCTION    LMGetBufTgFFlg
  1453.     ENDIF
  1454.  
  1455. ;
  1456. ; pascal void LMSetBufTgFFlg(SInt16 value)
  1457. ;
  1458.     IF ¬ GENERATINGCFM THEN
  1459.         Macro
  1460.         _LMSetBufTgFFlg         &src=(sp)+
  1461.         move.w               &src,$0300
  1462.         EndM
  1463.     ELSE
  1464.         IMPORT_CFM_FUNCTION    LMSetBufTgFFlg
  1465.     ENDIF
  1466.  
  1467. ;
  1468. ; pascal SInt16 LMGetBufTgFBkNum(void)
  1469. ;
  1470.     IF ¬ GENERATINGCFM THEN
  1471.         Macro
  1472.         _LMGetBufTgFBkNum         &dest=(sp)
  1473.         move.w               $0302,&dest
  1474.         EndM
  1475.     ELSE
  1476.         IMPORT_CFM_FUNCTION    LMGetBufTgFBkNum
  1477.     ENDIF
  1478.  
  1479. ;
  1480. ; pascal void LMSetBufTgFBkNum(SInt16 value)
  1481. ;
  1482.     IF ¬ GENERATINGCFM THEN
  1483.         Macro
  1484.         _LMSetBufTgFBkNum         &src=(sp)+
  1485.         move.w               &src,$0302
  1486.         EndM
  1487.     ELSE
  1488.         IMPORT_CFM_FUNCTION    LMSetBufTgFBkNum
  1489.     ENDIF
  1490.  
  1491. ;
  1492. ; pascal SInt32 LMGetBufTgDate(void)
  1493. ;
  1494.     IF ¬ GENERATINGCFM THEN
  1495.         Macro
  1496.         _LMGetBufTgDate         &dest=(sp)
  1497.         move.l               $0304,&dest
  1498.         EndM
  1499.     ELSE
  1500.         IMPORT_CFM_FUNCTION    LMGetBufTgDate
  1501.     ENDIF
  1502.  
  1503. ;
  1504. ; pascal void LMSetBufTgDate(SInt32 value)
  1505. ;
  1506.     IF ¬ GENERATINGCFM THEN
  1507.         Macro
  1508.         _LMSetBufTgDate         &src=(sp)+
  1509.         move.l               &src,$0304
  1510.         EndM
  1511.     ELSE
  1512.         IMPORT_CFM_FUNCTION    LMSetBufTgDate
  1513.     ENDIF
  1514.  
  1515. ;
  1516. ; pascal SInt32 LMGetLo3Bytes(void)
  1517. ;
  1518.     IF ¬ GENERATINGCFM THEN
  1519.         Macro
  1520.         _LMGetLo3Bytes         &dest=(sp)
  1521.         move.l               $031A,&dest
  1522.         EndM
  1523.     ELSE
  1524.         IMPORT_CFM_FUNCTION    LMGetLo3Bytes
  1525.     ENDIF
  1526.  
  1527. ;
  1528. ; pascal void LMSetLo3Bytes(SInt32 value)
  1529. ;
  1530.     IF ¬ GENERATINGCFM THEN
  1531.         Macro
  1532.         _LMSetLo3Bytes         &src=(sp)+
  1533.         move.l               &src,$031A
  1534.         EndM
  1535.     ELSE
  1536.         IMPORT_CFM_FUNCTION    LMSetLo3Bytes
  1537.     ENDIF
  1538.  
  1539. ;
  1540. ; pascal SInt32 LMGetMinStack(void)
  1541. ;
  1542.     IF ¬ GENERATINGCFM THEN
  1543.         Macro
  1544.         _LMGetMinStack         &dest=(sp)
  1545.         move.l               $031E,&dest
  1546.         EndM
  1547.     ELSE
  1548.         IMPORT_CFM_FUNCTION    LMGetMinStack
  1549.     ENDIF
  1550.  
  1551. ;
  1552. ; pascal void LMSetMinStack(SInt32 value)
  1553. ;
  1554.     IF ¬ GENERATINGCFM THEN
  1555.         Macro
  1556.         _LMSetMinStack         &src=(sp)+
  1557.         move.l               &src,$031E
  1558.         EndM
  1559.     ELSE
  1560.         IMPORT_CFM_FUNCTION    LMSetMinStack
  1561.     ENDIF
  1562.  
  1563. ;
  1564. ; pascal SInt32 LMGetDefltStack(void)
  1565. ;
  1566.     IF ¬ GENERATINGCFM THEN
  1567.         Macro
  1568.         _LMGetDefltStack         &dest=(sp)
  1569.         move.l               $0322,&dest
  1570.         EndM
  1571.     ELSE
  1572.         IMPORT_CFM_FUNCTION    LMGetDefltStack
  1573.     ENDIF
  1574.  
  1575. ;
  1576. ; pascal void LMSetDefltStack(SInt32 value)
  1577. ;
  1578.     IF ¬ GENERATINGCFM THEN
  1579.         Macro
  1580.         _LMSetDefltStack         &src=(sp)+
  1581.         move.l               &src,$0322
  1582.         EndM
  1583.     ELSE
  1584.         IMPORT_CFM_FUNCTION    LMSetDefltStack
  1585.     ENDIF
  1586.  
  1587. ;
  1588. ; pascal Handle LMGetGZRootHnd(void)
  1589. ;
  1590.     IF ¬ GENERATINGCFM THEN
  1591.         Macro
  1592.         _LMGetGZRootHnd         &dest=(sp)
  1593.         move.l               $0328,&dest
  1594.         EndM
  1595.     ELSE
  1596.         IMPORT_CFM_FUNCTION    LMGetGZRootHnd
  1597.     ENDIF
  1598.  
  1599. ;
  1600. ; pascal void LMSetGZRootHnd(Handle value)
  1601. ;
  1602.     IF ¬ GENERATINGCFM THEN
  1603.         Macro
  1604.         _LMSetGZRootHnd         &src=(sp)+
  1605.         move.l               &src,$0328
  1606.         EndM
  1607.     ELSE
  1608.         IMPORT_CFM_FUNCTION    LMSetGZRootHnd
  1609.     ENDIF
  1610.  
  1611. ;
  1612. ; pascal Handle LMGetGZMoveHnd(void)
  1613. ;
  1614.     IF ¬ GENERATINGCFM THEN
  1615.         Macro
  1616.         _LMGetGZMoveHnd         &dest=(sp)
  1617.         move.l               $0330,&dest
  1618.         EndM
  1619.     ELSE
  1620.         IMPORT_CFM_FUNCTION    LMGetGZMoveHnd
  1621.     ENDIF
  1622.  
  1623. ;
  1624. ; pascal void LMSetGZMoveHnd(Handle value)
  1625. ;
  1626.     IF ¬ GENERATINGCFM THEN
  1627.         Macro
  1628.         _LMSetGZMoveHnd         &src=(sp)+
  1629.         move.l               &src,$0330
  1630.         EndM
  1631.     ELSE
  1632.         IMPORT_CFM_FUNCTION    LMSetGZMoveHnd
  1633.     ENDIF
  1634.  
  1635. ;
  1636. ; pascal Ptr LMGetFCBSPtr(void)
  1637. ;
  1638.     IF ¬ GENERATINGCFM THEN
  1639.         Macro
  1640.         _LMGetFCBSPtr         &dest=(sp)
  1641.         move.l               $034E,&dest
  1642.         EndM
  1643.     ELSE
  1644.         IMPORT_CFM_FUNCTION    LMGetFCBSPtr
  1645.     ENDIF
  1646.  
  1647. ;
  1648. ; pascal void LMSetFCBSPtr(Ptr value)
  1649. ;
  1650.     IF ¬ GENERATINGCFM THEN
  1651.         Macro
  1652.         _LMSetFCBSPtr         &src=(sp)+
  1653.         move.l               &src,$034E
  1654.         EndM
  1655.     ELSE
  1656.         IMPORT_CFM_FUNCTION    LMSetFCBSPtr
  1657.     ENDIF
  1658.  
  1659. ;
  1660. ; pascal Ptr LMGetDefVCBPtr(void)
  1661. ;
  1662.     IF ¬ GENERATINGCFM THEN
  1663.         Macro
  1664.         _LMGetDefVCBPtr         &dest=(sp)
  1665.         move.l               $0352,&dest
  1666.         EndM
  1667.     ELSE
  1668.         IMPORT_CFM_FUNCTION    LMGetDefVCBPtr
  1669.     ENDIF
  1670.  
  1671. ;
  1672. ; pascal void LMSetDefVCBPtr(Ptr value)
  1673. ;
  1674.     IF ¬ GENERATINGCFM THEN
  1675.         Macro
  1676.         _LMSetDefVCBPtr         &src=(sp)+
  1677.         move.l               &src,$0352
  1678.         EndM
  1679.     ELSE
  1680.         IMPORT_CFM_FUNCTION    LMSetDefVCBPtr
  1681.     ENDIF
  1682.  
  1683. ;
  1684. ; pascal SInt32 LMGetCurDirStore(void)
  1685. ;
  1686.     IF ¬ GENERATINGCFM THEN
  1687.         Macro
  1688.         _LMGetCurDirStore         &dest=(sp)
  1689.         move.l               $0398,&dest
  1690.         EndM
  1691.     ELSE
  1692.         IMPORT_CFM_FUNCTION    LMGetCurDirStore
  1693.     ENDIF
  1694.  
  1695. ;
  1696. ; pascal void LMSetCurDirStore(SInt32 value)
  1697. ;
  1698.     IF ¬ GENERATINGCFM THEN
  1699.         Macro
  1700.         _LMSetCurDirStore         &src=(sp)+
  1701.         move.l               &src,$0398
  1702.         EndM
  1703.     ELSE
  1704.         IMPORT_CFM_FUNCTION    LMSetCurDirStore
  1705.     ENDIF
  1706.  
  1707. ;
  1708. ; pascal UniversalProcPtr LMGetToExtFS(void)
  1709. ;
  1710.     IF ¬ GENERATINGCFM THEN
  1711.         Macro
  1712.         _LMGetToExtFS         &dest=(sp)
  1713.         move.l               $03F2,&dest
  1714.         EndM
  1715.     ELSE
  1716.         IMPORT_CFM_FUNCTION    LMGetToExtFS
  1717.     ENDIF
  1718.  
  1719. ;
  1720. ; pascal void LMSetToExtFS(UniversalProcPtr value)
  1721. ;
  1722.     IF ¬ GENERATINGCFM THEN
  1723.         Macro
  1724.         _LMSetToExtFS         &src=(sp)+
  1725.         move.l               &src,$03F2
  1726.         EndM
  1727.     ELSE
  1728.         IMPORT_CFM_FUNCTION    LMSetToExtFS
  1729.     ENDIF
  1730.  
  1731. ;
  1732. ; pascal SInt16 LMGetFSFCBLen(void)
  1733. ;
  1734.     IF ¬ GENERATINGCFM THEN
  1735.         Macro
  1736.         _LMGetFSFCBLen         &dest=(sp)
  1737.         move.w               $03F6,&dest
  1738.         EndM
  1739.     ELSE
  1740.         IMPORT_CFM_FUNCTION    LMGetFSFCBLen
  1741.     ENDIF
  1742.  
  1743. ;
  1744. ; pascal void LMSetFSFCBLen(SInt16 value)
  1745. ;
  1746.     IF ¬ GENERATINGCFM THEN
  1747.         Macro
  1748.         _LMSetFSFCBLen         &src=(sp)+
  1749.         move.w               &src,$03F6
  1750.         EndM
  1751.     ELSE
  1752.         IMPORT_CFM_FUNCTION    LMSetFSFCBLen
  1753.     ENDIF
  1754.  
  1755. ;
  1756. ; pascal Ptr LMGetScrnBase(void)
  1757. ;
  1758.     IF ¬ GENERATINGCFM THEN
  1759.         Macro
  1760.         _LMGetScrnBase         &dest=(sp)
  1761.         move.l               $0824,&dest
  1762.         EndM
  1763.     ELSE
  1764.         IMPORT_CFM_FUNCTION    LMGetScrnBase
  1765.     ENDIF
  1766.  
  1767. ;
  1768. ; pascal void LMSetScrnBase(Ptr value)
  1769. ;
  1770.     IF ¬ GENERATINGCFM THEN
  1771.         Macro
  1772.         _LMSetScrnBase         &src=(sp)+
  1773.         move.l               &src,$0824
  1774.         EndM
  1775.     ELSE
  1776.         IMPORT_CFM_FUNCTION    LMSetScrnBase
  1777.     ENDIF
  1778.  
  1779. ;
  1780. ; pascal GDHandle LMGetMainDevice(void)
  1781. ;
  1782.     IF ¬ GENERATINGCFM THEN
  1783.         Macro
  1784.         _LMGetMainDevice         &dest=(sp)
  1785.         move.l               $08A4,&dest
  1786.         EndM
  1787.     ELSE
  1788.         IMPORT_CFM_FUNCTION    LMGetMainDevice
  1789.     ENDIF
  1790.  
  1791. ;
  1792. ; pascal void LMSetMainDevice(GDHandle value)
  1793. ;
  1794.     IF ¬ GENERATINGCFM THEN
  1795.         Macro
  1796.         _LMSetMainDevice         &src=(sp)+
  1797.         move.l               &src,$08A4
  1798.         EndM
  1799.     ELSE
  1800.         IMPORT_CFM_FUNCTION    LMSetMainDevice
  1801.     ENDIF
  1802.  
  1803. ;
  1804. ; pascal GDHandle LMGetDeviceList(void)
  1805. ;
  1806.     IF ¬ GENERATINGCFM THEN
  1807.         Macro
  1808.         _LMGetDeviceList         &dest=(sp)
  1809.         move.l               $08A8,&dest
  1810.         EndM
  1811.     ELSE
  1812.         IMPORT_CFM_FUNCTION    LMGetDeviceList
  1813.     ENDIF
  1814.  
  1815. ;
  1816. ; pascal void LMSetDeviceList(GDHandle value)
  1817. ;
  1818.     IF ¬ GENERATINGCFM THEN
  1819.         Macro
  1820.         _LMSetDeviceList         &src=(sp)+
  1821.         move.l               &src,$08A8
  1822.         EndM
  1823.     ELSE
  1824.         IMPORT_CFM_FUNCTION    LMSetDeviceList
  1825.     ENDIF
  1826.  
  1827. ;
  1828. ; pascal Handle LMGetQDColors(void)
  1829. ;
  1830.     IF ¬ GENERATINGCFM THEN
  1831.         Macro
  1832.         _LMGetQDColors         &dest=(sp)
  1833.         move.l               $08B0,&dest
  1834.         EndM
  1835.     ELSE
  1836.         IMPORT_CFM_FUNCTION    LMGetQDColors
  1837.     ENDIF
  1838.  
  1839. ;
  1840. ; pascal void LMSetQDColors(Handle value)
  1841. ;
  1842.     IF ¬ GENERATINGCFM THEN
  1843.         Macro
  1844.         _LMSetQDColors         &src=(sp)+
  1845.         move.l               &src,$08B0
  1846.         EndM
  1847.     ELSE
  1848.         IMPORT_CFM_FUNCTION    LMSetQDColors
  1849.     ENDIF
  1850.  
  1851. ;
  1852. ; pascal UInt8 LMGetCrsrBusy(void)
  1853. ;
  1854.     IF ¬ GENERATINGCFM THEN
  1855.         Macro
  1856.         _LMGetCrsrBusy         &dest=(sp)
  1857.         move.b               $08CD,&dest
  1858.         EndM
  1859.     ELSE
  1860.         IMPORT_CFM_FUNCTION    LMGetCrsrBusy
  1861.     ENDIF
  1862.  
  1863. ;
  1864. ; pascal void LMSetCrsrBusy(UInt8 value)
  1865. ;
  1866.     IF ¬ GENERATINGCFM THEN
  1867.         Macro
  1868.         _LMSetCrsrBusy         &src=(sp)+
  1869.         move.b               &src,$08CD
  1870.         EndM
  1871.     ELSE
  1872.         IMPORT_CFM_FUNCTION    LMSetCrsrBusy
  1873.     ENDIF
  1874.  
  1875. ;
  1876. ; pascal Handle LMGetWidthListHand(void)
  1877. ;
  1878.     IF ¬ GENERATINGCFM THEN
  1879.         Macro
  1880.         _LMGetWidthListHand         &dest=(sp)
  1881.         move.l               $08E4,&dest
  1882.         EndM
  1883.     ELSE
  1884.         IMPORT_CFM_FUNCTION    LMGetWidthListHand
  1885.     ENDIF
  1886.  
  1887. ;
  1888. ; pascal void LMSetWidthListHand(Handle value)
  1889. ;
  1890.     IF ¬ GENERATINGCFM THEN
  1891.         Macro
  1892.         _LMSetWidthListHand         &src=(sp)+
  1893.         move.l               &src,$08E4
  1894.         EndM
  1895.     ELSE
  1896.         IMPORT_CFM_FUNCTION    LMSetWidthListHand
  1897.     ENDIF
  1898.  
  1899. ;
  1900. ; pascal SInt16 LMGetJournalRef(void)
  1901. ;
  1902.     IF ¬ GENERATINGCFM THEN
  1903.         Macro
  1904.         _LMGetJournalRef         &dest=(sp)
  1905.         move.w               $08E8,&dest
  1906.         EndM
  1907.     ELSE
  1908.         IMPORT_CFM_FUNCTION    LMGetJournalRef
  1909.     ENDIF
  1910.  
  1911. ;
  1912. ; pascal void LMSetJournalRef(SInt16 value)
  1913. ;
  1914.     IF ¬ GENERATINGCFM THEN
  1915.         Macro
  1916.         _LMSetJournalRef         &src=(sp)+
  1917.         move.w               &src,$08E8
  1918.         EndM
  1919.     ELSE
  1920.         IMPORT_CFM_FUNCTION    LMSetJournalRef
  1921.     ENDIF
  1922.  
  1923. ;
  1924. ; pascal SInt16 LMGetCrsrThresh(void)
  1925. ;
  1926.     IF ¬ GENERATINGCFM THEN
  1927.         Macro
  1928.         _LMGetCrsrThresh         &dest=(sp)
  1929.         move.w               $08EC,&dest
  1930.         EndM
  1931.     ELSE
  1932.         IMPORT_CFM_FUNCTION    LMGetCrsrThresh
  1933.     ENDIF
  1934.  
  1935. ;
  1936. ; pascal void LMSetCrsrThresh(SInt16 value)
  1937. ;
  1938.     IF ¬ GENERATINGCFM THEN
  1939.         Macro
  1940.         _LMSetCrsrThresh         &src=(sp)+
  1941.         move.w               &src,$08EC
  1942.         EndM
  1943.     ELSE
  1944.         IMPORT_CFM_FUNCTION    LMSetCrsrThresh
  1945.     ENDIF
  1946.  
  1947. ;
  1948. ; pascal UniversalProcPtr LMGetJFetch(void)
  1949. ;
  1950.     IF ¬ GENERATINGCFM THEN
  1951.         Macro
  1952.         _LMGetJFetch         &dest=(sp)
  1953.         move.l               $08F4,&dest
  1954.         EndM
  1955.     ELSE
  1956.         IMPORT_CFM_FUNCTION    LMGetJFetch
  1957.     ENDIF
  1958.  
  1959. ;
  1960. ; pascal void LMSetJFetch(UniversalProcPtr value)
  1961. ;
  1962.     IF ¬ GENERATINGCFM THEN
  1963.         Macro
  1964.         _LMSetJFetch         &src=(sp)+
  1965.         move.l               &src,$08F4
  1966.         EndM
  1967.     ELSE
  1968.         IMPORT_CFM_FUNCTION    LMSetJFetch
  1969.     ENDIF
  1970.  
  1971. ;
  1972. ; pascal UniversalProcPtr LMGetJStash(void)
  1973. ;
  1974.     IF ¬ GENERATINGCFM THEN
  1975.         Macro
  1976.         _LMGetJStash         &dest=(sp)
  1977.         move.l               $08F8,&dest
  1978.         EndM
  1979.     ELSE
  1980.         IMPORT_CFM_FUNCTION    LMGetJStash
  1981.     ENDIF
  1982.  
  1983. ;
  1984. ; pascal void LMSetJStash(UniversalProcPtr value)
  1985. ;
  1986.     IF ¬ GENERATINGCFM THEN
  1987.         Macro
  1988.         _LMSetJStash         &src=(sp)+
  1989.         move.l               &src,$08F8
  1990.         EndM
  1991.     ELSE
  1992.         IMPORT_CFM_FUNCTION    LMSetJStash
  1993.     ENDIF
  1994.  
  1995. ;
  1996. ; pascal UniversalProcPtr LMGetJIODone(void)
  1997. ;
  1998.     IF ¬ GENERATINGCFM THEN
  1999.         Macro
  2000.         _LMGetJIODone         &dest=(sp)
  2001.         move.l               $08FC,&dest
  2002.         EndM
  2003.     ELSE
  2004.         IMPORT_CFM_FUNCTION    LMGetJIODone
  2005.     ENDIF
  2006.  
  2007. ;
  2008. ; pascal void LMSetJIODone(UniversalProcPtr value)
  2009. ;
  2010.     IF ¬ GENERATINGCFM THEN
  2011.         Macro
  2012.         _LMSetJIODone         &src=(sp)+
  2013.         move.l               &src,$08FC
  2014.         EndM
  2015.     ELSE
  2016.         IMPORT_CFM_FUNCTION    LMSetJIODone
  2017.     ENDIF
  2018.  
  2019. ;
  2020. ; pascal SInt16 LMGetCurApRefNum(void)
  2021. ;
  2022.     IF ¬ GENERATINGCFM THEN
  2023.         Macro
  2024.         _LMGetCurApRefNum         &dest=(sp)
  2025.         move.w               $0900,&dest
  2026.         EndM
  2027.     ELSE
  2028.         IMPORT_CFM_FUNCTION    LMGetCurApRefNum
  2029.     ENDIF
  2030.  
  2031. ;
  2032. ; pascal void LMSetCurApRefNum(SInt16 value)
  2033. ;
  2034.     IF ¬ GENERATINGCFM THEN
  2035.         Macro
  2036.         _LMSetCurApRefNum         &src=(sp)+
  2037.         move.w               &src,$0900
  2038.         EndM
  2039.     ELSE
  2040.         IMPORT_CFM_FUNCTION    LMSetCurApRefNum
  2041.     ENDIF
  2042.  
  2043. ;
  2044. ; pascal Ptr LMGetCurrentA5(void)
  2045. ;
  2046.     IF ¬ GENERATINGCFM THEN
  2047.         Macro
  2048.         _LMGetCurrentA5         &dest=(sp)
  2049.         move.l               $0904,&dest
  2050.         EndM
  2051.     ELSE
  2052.         IMPORT_CFM_FUNCTION    LMGetCurrentA5
  2053.     ENDIF
  2054.  
  2055. ;
  2056. ; pascal void LMSetCurrentA5(Ptr value)
  2057. ;
  2058.     IF ¬ GENERATINGCFM THEN
  2059.         Macro
  2060.         _LMSetCurrentA5         &src=(sp)+
  2061.         move.l               &src,$0904
  2062.         EndM
  2063.     ELSE
  2064.         IMPORT_CFM_FUNCTION    LMSetCurrentA5
  2065.     ENDIF
  2066.  
  2067. ;
  2068. ; pascal Ptr LMGetCurStackBase(void)
  2069. ;
  2070.     IF ¬ GENERATINGCFM THEN
  2071.         Macro
  2072.         _LMGetCurStackBase         &dest=(sp)
  2073.         move.l               $0908,&dest
  2074.         EndM
  2075.     ELSE
  2076.         IMPORT_CFM_FUNCTION    LMGetCurStackBase
  2077.     ENDIF
  2078.  
  2079. ;
  2080. ; pascal void LMSetCurStackBase(Ptr value)
  2081. ;
  2082.     IF ¬ GENERATINGCFM THEN
  2083.         Macro
  2084.         _LMSetCurStackBase         &src=(sp)+
  2085.         move.l               &src,$0908
  2086.         EndM
  2087.     ELSE
  2088.         IMPORT_CFM_FUNCTION    LMSetCurStackBase
  2089.     ENDIF
  2090.  
  2091. ;
  2092. ; pascal SInt16 LMGetCurJTOffset(void)
  2093. ;
  2094.     IF ¬ GENERATINGCFM THEN
  2095.         Macro
  2096.         _LMGetCurJTOffset         &dest=(sp)
  2097.         move.w               $0934,&dest
  2098.         EndM
  2099.     ELSE
  2100.         IMPORT_CFM_FUNCTION    LMGetCurJTOffset
  2101.     ENDIF
  2102.  
  2103. ;
  2104. ; pascal void LMSetCurJTOffset(SInt16 value)
  2105. ;
  2106.     IF ¬ GENERATINGCFM THEN
  2107.         Macro
  2108.         _LMSetCurJTOffset         &src=(sp)+
  2109.         move.w               &src,$0934
  2110.         EndM
  2111.     ELSE
  2112.         IMPORT_CFM_FUNCTION    LMSetCurJTOffset
  2113.     ENDIF
  2114.  
  2115. ;
  2116. ; pascal SInt16 LMGetCurPageOption(void)
  2117. ;
  2118.     IF ¬ GENERATINGCFM THEN
  2119.         Macro
  2120.         _LMGetCurPageOption         &dest=(sp)
  2121.         move.w               $0936,&dest
  2122.         EndM
  2123.     ELSE
  2124.         IMPORT_CFM_FUNCTION    LMGetCurPageOption
  2125.     ENDIF
  2126.  
  2127. ;
  2128. ; pascal void LMSetCurPageOption(SInt16 value)
  2129. ;
  2130.     IF ¬ GENERATINGCFM THEN
  2131.         Macro
  2132.         _LMSetCurPageOption         &src=(sp)+
  2133.         move.w               &src,$0936
  2134.         EndM
  2135.     ELSE
  2136.         IMPORT_CFM_FUNCTION    LMSetCurPageOption
  2137.     ENDIF
  2138.  
  2139. ;
  2140. ; pascal UInt8 LMGetHiliteMode(void)
  2141. ;
  2142.     IF ¬ GENERATINGCFM THEN
  2143.         Macro
  2144.         _LMGetHiliteMode         &dest=(sp)
  2145.         move.b               $0938,&dest
  2146.         EndM
  2147.     ELSE
  2148.         IMPORT_CFM_FUNCTION    LMGetHiliteMode
  2149.     ENDIF
  2150.  
  2151. ;
  2152. ; pascal void LMSetHiliteMode(UInt8 value)
  2153. ;
  2154.     IF ¬ GENERATINGCFM THEN
  2155.         Macro
  2156.         _LMSetHiliteMode         &src=(sp)+
  2157.         move.b               &src,$0938
  2158.         EndM
  2159.     ELSE
  2160.         IMPORT_CFM_FUNCTION    LMSetHiliteMode
  2161.     ENDIF
  2162.  
  2163. ;
  2164. ; pascal SInt16 LMGetPrintErr(void)
  2165. ;
  2166.     IF ¬ GENERATINGCFM THEN
  2167.         Macro
  2168.         _LMGetPrintErr         &dest=(sp)
  2169.         move.w               $0944,&dest
  2170.         EndM
  2171.     ELSE
  2172.         IMPORT_CFM_FUNCTION    LMGetPrintErr
  2173.     ENDIF
  2174.  
  2175. ;
  2176. ; pascal void LMSetPrintErr(SInt16 value)
  2177. ;
  2178.     IF ¬ GENERATINGCFM THEN
  2179.         Macro
  2180.         _LMSetPrintErr         &src=(sp)+
  2181.         move.w               &src,$0944
  2182.         EndM
  2183.     ELSE
  2184.         IMPORT_CFM_FUNCTION    LMSetPrintErr
  2185.     ENDIF
  2186.  
  2187. ;
  2188. ; pascal SInt32 LMGetScrapSize(void)
  2189. ;
  2190.     IF ¬ GENERATINGCFM THEN
  2191.         Macro
  2192.         _LMGetScrapSize         &dest=(sp)
  2193.         move.l               $0960,&dest
  2194.         EndM
  2195.     ELSE
  2196.         IMPORT_CFM_FUNCTION    LMGetScrapSize
  2197.     ENDIF
  2198.  
  2199. ;
  2200. ; pascal void LMSetScrapSize(SInt32 value)
  2201. ;
  2202.     IF ¬ GENERATINGCFM THEN
  2203.         Macro
  2204.         _LMSetScrapSize         &src=(sp)+
  2205.         move.l               &src,$0960
  2206.         EndM
  2207.     ELSE
  2208.         IMPORT_CFM_FUNCTION    LMSetScrapSize
  2209.     ENDIF
  2210.  
  2211. ;
  2212. ; pascal Handle LMGetScrapHandle(void)
  2213. ;
  2214.     IF ¬ GENERATINGCFM THEN
  2215.         Macro
  2216.         _LMGetScrapHandle         &dest=(sp)
  2217.         move.l               $0964,&dest
  2218.         EndM
  2219.     ELSE
  2220.         IMPORT_CFM_FUNCTION    LMGetScrapHandle
  2221.     ENDIF
  2222.  
  2223. ;
  2224. ; pascal void LMSetScrapHandle(Handle value)
  2225. ;
  2226.     IF ¬ GENERATINGCFM THEN
  2227.         Macro
  2228.         _LMSetScrapHandle         &src=(sp)+
  2229.         move.l               &src,$0964
  2230.         EndM
  2231.     ELSE
  2232.         IMPORT_CFM_FUNCTION    LMSetScrapHandle
  2233.     ENDIF
  2234.  
  2235. ;
  2236. ; pascal SInt16 LMGetScrapCount(void)
  2237. ;
  2238.     IF ¬ GENERATINGCFM THEN
  2239.         Macro
  2240.         _LMGetScrapCount         &dest=(sp)
  2241.         move.w               $0968,&dest
  2242.         EndM
  2243.     ELSE
  2244.         IMPORT_CFM_FUNCTION    LMGetScrapCount
  2245.     ENDIF
  2246.  
  2247. ;
  2248. ; pascal void LMSetScrapCount(SInt16 value)
  2249. ;
  2250.     IF ¬ GENERATINGCFM THEN
  2251.         Macro
  2252.         _LMSetScrapCount         &src=(sp)+
  2253.         move.w               &src,$0968
  2254.         EndM
  2255.     ELSE
  2256.         IMPORT_CFM_FUNCTION    LMSetScrapCount
  2257.     ENDIF
  2258.  
  2259. ;
  2260. ; pascal SInt16 LMGetScrapState(void)
  2261. ;
  2262.     IF ¬ GENERATINGCFM THEN
  2263.         Macro
  2264.         _LMGetScrapState         &dest=(sp)
  2265.         move.w               $096A,&dest
  2266.         EndM
  2267.     ELSE
  2268.         IMPORT_CFM_FUNCTION    LMGetScrapState
  2269.     ENDIF
  2270.  
  2271. ;
  2272. ; pascal void LMSetScrapState(SInt16 value)
  2273. ;
  2274.     IF ¬ GENERATINGCFM THEN
  2275.         Macro
  2276.         _LMSetScrapState         &src=(sp)+
  2277.         move.w               &src,$096A
  2278.         EndM
  2279.     ELSE
  2280.         IMPORT_CFM_FUNCTION    LMSetScrapState
  2281.     ENDIF
  2282.  
  2283. ;
  2284. ; pascal StringPtr LMGetScrapName(void)
  2285. ;
  2286.     IF ¬ GENERATINGCFM THEN
  2287.         Macro
  2288.         _LMGetScrapName         &dest=(sp)
  2289.         move.l               $096C,&dest
  2290.         EndM
  2291.     ELSE
  2292.         IMPORT_CFM_FUNCTION    LMGetScrapName
  2293.     ENDIF
  2294.  
  2295. ;
  2296. ; pascal void LMSetScrapName(StringPtr value)
  2297. ;
  2298.     IF ¬ GENERATINGCFM THEN
  2299.         Macro
  2300.         _LMSetScrapName         &src=(sp)+
  2301.         move.l               &src,$096C
  2302.         EndM
  2303.     ELSE
  2304.         IMPORT_CFM_FUNCTION    LMSetScrapName
  2305.     ENDIF
  2306.  
  2307. ;
  2308. ; pascal Handle LMGetROMFont0(void)
  2309. ;
  2310.     IF ¬ GENERATINGCFM THEN
  2311.         Macro
  2312.         _LMGetROMFont0         &dest=(sp)
  2313.         move.l               $0980,&dest
  2314.         EndM
  2315.     ELSE
  2316.         IMPORT_CFM_FUNCTION    LMGetROMFont0
  2317.     ENDIF
  2318.  
  2319. ;
  2320. ; pascal void LMSetROMFont0(Handle value)
  2321. ;
  2322.     IF ¬ GENERATINGCFM THEN
  2323.         Macro
  2324.         _LMSetROMFont0         &src=(sp)+
  2325.         move.l               &src,$0980
  2326.         EndM
  2327.     ELSE
  2328.         IMPORT_CFM_FUNCTION    LMSetROMFont0
  2329.     ENDIF
  2330.  
  2331. ;
  2332. ; pascal SInt16 LMGetApFontID(void)
  2333. ;
  2334.     IF ¬ GENERATINGCFM THEN
  2335.         Macro
  2336.         _LMGetApFontID         &dest=(sp)
  2337.         move.w               $0984,&dest
  2338.         EndM
  2339.     ELSE
  2340.         IMPORT_CFM_FUNCTION    LMGetApFontID
  2341.     ENDIF
  2342.  
  2343. ;
  2344. ; pascal void LMSetApFontID(SInt16 value)
  2345. ;
  2346.     IF ¬ GENERATINGCFM THEN
  2347.         Macro
  2348.         _LMSetApFontID         &src=(sp)+
  2349.         move.w               &src,$0984
  2350.         EndM
  2351.     ELSE
  2352.         IMPORT_CFM_FUNCTION    LMSetApFontID
  2353.     ENDIF
  2354.  
  2355. ;
  2356. ; pascal WindowRef LMGetWindowList(void)
  2357. ;
  2358.     IF ¬ GENERATINGCFM THEN
  2359.         Macro
  2360.         _LMGetWindowList         &dest=(sp)
  2361.         move.l               $09D6,&dest
  2362.         EndM
  2363.     ELSE
  2364.         IMPORT_CFM_FUNCTION    LMGetWindowList
  2365.     ENDIF
  2366.  
  2367. ;
  2368. ; pascal SInt16 LMGetSaveUpdate(void)
  2369. ;
  2370.     IF ¬ GENERATINGCFM THEN
  2371.         Macro
  2372.         _LMGetSaveUpdate         &dest=(sp)
  2373.         move.w               $09DA,&dest
  2374.         EndM
  2375.     ELSE
  2376.         IMPORT_CFM_FUNCTION    LMGetSaveUpdate
  2377.     ENDIF
  2378.  
  2379. ;
  2380. ; pascal void LMSetSaveUpdate(SInt16 value)
  2381. ;
  2382.     IF ¬ GENERATINGCFM THEN
  2383.         Macro
  2384.         _LMSetSaveUpdate         &src=(sp)+
  2385.         move.w               &src,$09DA
  2386.         EndM
  2387.     ELSE
  2388.         IMPORT_CFM_FUNCTION    LMSetSaveUpdate
  2389.     ENDIF
  2390.  
  2391. ;
  2392. ; pascal SInt16 LMGetPaintWhite(void)
  2393. ;
  2394.     IF ¬ GENERATINGCFM THEN
  2395.         Macro
  2396.         _LMGetPaintWhite         &dest=(sp)
  2397.         move.w               $09DC,&dest
  2398.         EndM
  2399.     ELSE
  2400.         IMPORT_CFM_FUNCTION    LMGetPaintWhite
  2401.     ENDIF
  2402.  
  2403. ;
  2404. ; pascal void LMSetPaintWhite(SInt16 value)
  2405. ;
  2406.     IF ¬ GENERATINGCFM THEN
  2407.         Macro
  2408.         _LMSetPaintWhite         &src=(sp)+
  2409.         move.w               &src,$09DC
  2410.         EndM
  2411.     ELSE
  2412.         IMPORT_CFM_FUNCTION    LMSetPaintWhite
  2413.     ENDIF
  2414.  
  2415. ;
  2416. ; pascal GrafPtr LMGetWMgrPort(void)
  2417. ;
  2418.     IF ¬ GENERATINGCFM THEN
  2419.         Macro
  2420.         _LMGetWMgrPort         &dest=(sp)
  2421.         move.l               $09DE,&dest
  2422.         EndM
  2423.     ELSE
  2424.         IMPORT_CFM_FUNCTION    LMGetWMgrPort
  2425.     ENDIF
  2426.  
  2427. ;
  2428. ; pascal void LMSetWMgrPort(GrafPtr value)
  2429. ;
  2430.     IF ¬ GENERATINGCFM THEN
  2431.         Macro
  2432.         _LMSetWMgrPort         &src=(sp)+
  2433.         move.l               &src,$09DE
  2434.         EndM
  2435.     ELSE
  2436.         IMPORT_CFM_FUNCTION    LMSetWMgrPort
  2437.     ENDIF
  2438.  
  2439. ;
  2440. ; pascal RgnHandle LMGetGrayRgn(void)
  2441. ;
  2442.     IF ¬ GENERATINGCFM THEN
  2443.         Macro
  2444.         _LMGetGrayRgn         &dest=(sp)
  2445.         move.l               $09EE,&dest
  2446.         EndM
  2447.     ELSE
  2448.         IMPORT_CFM_FUNCTION    LMGetGrayRgn
  2449.     ENDIF
  2450.  
  2451. ;
  2452. ; pascal UniversalProcPtr LMGetDragHook(void)
  2453. ;
  2454.     IF ¬ GENERATINGCFM THEN
  2455.         Macro
  2456.         _LMGetDragHook         &dest=(sp)
  2457.         move.l               $09F6,&dest
  2458.         EndM
  2459.     ELSE
  2460.         IMPORT_CFM_FUNCTION    LMGetDragHook
  2461.     ENDIF
  2462.  
  2463. ;
  2464. ; pascal void LMSetDragHook(UniversalProcPtr value)
  2465. ;
  2466.     IF ¬ GENERATINGCFM THEN
  2467.         Macro
  2468.         _LMSetDragHook         &src=(sp)+
  2469.         move.l               &src,$09F6
  2470.         EndM
  2471.     ELSE
  2472.         IMPORT_CFM_FUNCTION    LMSetDragHook
  2473.     ENDIF
  2474.  
  2475. ;
  2476. ; To best work with future versions of the window manager,
  2477. ; avoid using anything not defined with STRICT_WINDOWS
  2478. ; set to true.  Most, if not all of these will still
  2479. ; be supported in the next major version of the window manager
  2480. ; but will trigger non-optimal compatibility code paths that
  2481. ; should be avoided if possible.
  2482. ;
  2483.     IF ¬ STRICT_WINDOWS  THEN
  2484. ;
  2485. ; There is no reason to set the window list directly.
  2486. ; Use BringToFront and SendBehind.
  2487. ;
  2488. ; If you need to do floating windows, avoid using GhostWindow 
  2489. ; and especially avoid patching the window manager.
  2490. ;
  2491. ; See Dean Yu's article in Develop 15 about how to implement floating
  2492. ; windows using low-level window manager calls.  The next generation
  2493. ; Macintosh Window Manager will have built-in support for floating
  2494. ; and modal windows.
  2495. ;
  2496. ;
  2497. ; pascal void LMSetWindowList(WindowRef value)
  2498. ;
  2499.     IF ¬ GENERATINGCFM THEN
  2500.         Macro
  2501.         _LMSetWindowList         &src=(sp)+
  2502.         move.l               &src,$09D6
  2503.         EndM
  2504.     ELSE
  2505.         IMPORT_CFM_FUNCTION    LMSetWindowList
  2506.     ENDIF
  2507.  
  2508. ;
  2509. ; pascal WindowRef LMGetGhostWindow(void)
  2510. ;
  2511.     IF ¬ GENERATINGCFM THEN
  2512.         Macro
  2513.         _LMGetGhostWindow         &dest=(sp)
  2514.         move.l               $0A84,&dest
  2515.         EndM
  2516.     ELSE
  2517.         IMPORT_CFM_FUNCTION    LMGetGhostWindow
  2518.     ENDIF
  2519.  
  2520. ;
  2521. ; pascal void LMSetGhostWindow(WindowRef value)
  2522. ;
  2523.     IF ¬ GENERATINGCFM THEN
  2524.         Macro
  2525.         _LMSetGhostWindow         &src=(sp)+
  2526.         move.l               &src,$0A84
  2527.         EndM
  2528.     ELSE
  2529.         IMPORT_CFM_FUNCTION    LMSetGhostWindow
  2530.     ENDIF
  2531.  
  2532. ;
  2533. ; The auxiliary window record list will be empty in future
  2534. ; versions of the window manager.  There is no reason to 
  2535. ; walk it or change it. 
  2536. ;
  2537. ;
  2538. ; pascal AuxWinHandle LMGetAuxWinHead(void)
  2539. ;
  2540.     IF ¬ GENERATINGCFM THEN
  2541.         Macro
  2542.         _LMGetAuxWinHead         &dest=(sp)
  2543.         move.l               $0CD0,&dest
  2544.         EndM
  2545.     ELSE
  2546.         IMPORT_CFM_FUNCTION    LMGetAuxWinHead
  2547.     ENDIF
  2548.  
  2549. ;
  2550. ; pascal void LMSetAuxWinHead(AuxWinHandle value)
  2551. ;
  2552.     IF ¬ GENERATINGCFM THEN
  2553.         Macro
  2554.         _LMSetAuxWinHead         &src=(sp)+
  2555.         move.l               &src,$0CD0
  2556.         EndM
  2557.     ELSE
  2558.         IMPORT_CFM_FUNCTION    LMSetAuxWinHead
  2559.     ENDIF
  2560.  
  2561. ;
  2562. ; Please rely on the event manager to deliver activate and 
  2563. ; deactivate events and on the window manager to generate them.
  2564. ;
  2565. ; The next generation window manager will queue these events
  2566. ; rather than just slamming these lowmems with the latest
  2567. ; generated event, so it pays to rely on the event manager.
  2568. ;
  2569. ;
  2570. ; pascal WindowRef LMGetCurActivate(void)
  2571. ;
  2572.     IF ¬ GENERATINGCFM THEN
  2573.         Macro
  2574.         _LMGetCurActivate         &dest=(sp)
  2575.         move.l               $0A64,&dest
  2576.         EndM
  2577.     ELSE
  2578.         IMPORT_CFM_FUNCTION    LMGetCurActivate
  2579.     ENDIF
  2580.  
  2581. ;
  2582. ; pascal void LMSetCurActivate(WindowRef value)
  2583. ;
  2584.     IF ¬ GENERATINGCFM THEN
  2585.         Macro
  2586.         _LMSetCurActivate         &src=(sp)+
  2587.         move.l               &src,$0A64
  2588.         EndM
  2589.     ELSE
  2590.         IMPORT_CFM_FUNCTION    LMSetCurActivate
  2591.     ENDIF
  2592.  
  2593. ;
  2594. ; pascal WindowRef LMGetCurDeactive(void)
  2595. ;
  2596.     IF ¬ GENERATINGCFM THEN
  2597.         Macro
  2598.         _LMGetCurDeactive         &dest=(sp)
  2599.         move.l               $0A68,&dest
  2600.         EndM
  2601.     ELSE
  2602.         IMPORT_CFM_FUNCTION    LMGetCurDeactive
  2603.     ENDIF
  2604.  
  2605. ;
  2606. ; pascal void LMSetCurDeactive(WindowRef value)
  2607. ;
  2608.     IF ¬ GENERATINGCFM THEN
  2609.         Macro
  2610.         _LMSetCurDeactive         &src=(sp)+
  2611.         move.l               &src,$0A68
  2612.         EndM
  2613.     ELSE
  2614.         IMPORT_CFM_FUNCTION    LMSetCurDeactive
  2615.     ENDIF
  2616.  
  2617. ;
  2618. ; pascal RgnHandle LMGetOldStructure(void)
  2619. ;
  2620.     IF ¬ GENERATINGCFM THEN
  2621.         Macro
  2622.         _LMGetOldStructure         &dest=(sp)
  2623.         move.l               $09E6,&dest
  2624.         EndM
  2625.     ELSE
  2626.         IMPORT_CFM_FUNCTION    LMGetOldStructure
  2627.     ENDIF
  2628.  
  2629. ;
  2630. ; pascal void LMSetOldStructure(RgnHandle value)
  2631. ;
  2632.     IF ¬ GENERATINGCFM THEN
  2633.         Macro
  2634.         _LMSetOldStructure         &src=(sp)+
  2635.         move.l               &src,$09E6
  2636.         EndM
  2637.     ELSE
  2638.         IMPORT_CFM_FUNCTION    LMSetOldStructure
  2639.     ENDIF
  2640.  
  2641. ;
  2642. ; pascal RgnHandle LMGetOldContent(void)
  2643. ;
  2644.     IF ¬ GENERATINGCFM THEN
  2645.         Macro
  2646.         _LMGetOldContent         &dest=(sp)
  2647.         move.l               $09EA,&dest
  2648.         EndM
  2649.     ELSE
  2650.         IMPORT_CFM_FUNCTION    LMGetOldContent
  2651.     ENDIF
  2652.  
  2653. ;
  2654. ; pascal void LMSetOldContent(RgnHandle value)
  2655. ;
  2656.     IF ¬ GENERATINGCFM THEN
  2657.         Macro
  2658.         _LMSetOldContent         &src=(sp)+
  2659.         move.l               &src,$09EA
  2660.         EndM
  2661.     ELSE
  2662.         IMPORT_CFM_FUNCTION    LMSetOldContent
  2663.     ENDIF
  2664.  
  2665. ;
  2666. ; Please don't mess with the gray region.  There has
  2667. ; to be a better way.  If not, please manipulate the
  2668. ; existing region, don't change the value of the lowmem.
  2669. ;
  2670. ;
  2671. ; pascal void LMSetGrayRgn(RgnHandle value)
  2672. ;
  2673.     IF ¬ GENERATINGCFM THEN
  2674.         Macro
  2675.         _LMSetGrayRgn         &src=(sp)+
  2676.         move.l               &src,$09EE
  2677.         EndM
  2678.     ELSE
  2679.         IMPORT_CFM_FUNCTION    LMSetGrayRgn
  2680.     ENDIF
  2681.  
  2682. ;
  2683. ; pascal RgnHandle LMGetSaveVisRgn(void)
  2684. ;
  2685.     IF ¬ GENERATINGCFM THEN
  2686.         Macro
  2687.         _LMGetSaveVisRgn         &dest=(sp)
  2688.         move.l               $09F2,&dest
  2689.         EndM
  2690.     ELSE
  2691.         IMPORT_CFM_FUNCTION    LMGetSaveVisRgn
  2692.     ENDIF
  2693.  
  2694. ;
  2695. ; pascal void LMSetSaveVisRgn(RgnHandle value)
  2696. ;
  2697.     IF ¬ GENERATINGCFM THEN
  2698.         Macro
  2699.         _LMSetSaveVisRgn         &src=(sp)+
  2700.         move.l               &src,$09F2
  2701.         EndM
  2702.     ELSE
  2703.         IMPORT_CFM_FUNCTION    LMSetSaveVisRgn
  2704.     ENDIF
  2705.  
  2706.     ENDIF
  2707. ;
  2708. ; pascal SInt32 LMGetOneOne(void)
  2709. ;
  2710.     IF ¬ GENERATINGCFM THEN
  2711.         Macro
  2712.         _LMGetOneOne         &dest=(sp)
  2713.         move.l               $0A02,&dest
  2714.         EndM
  2715.     ELSE
  2716.         IMPORT_CFM_FUNCTION    LMGetOneOne
  2717.     ENDIF
  2718.  
  2719. ;
  2720. ; pascal void LMSetOneOne(SInt32 value)
  2721. ;
  2722.     IF ¬ GENERATINGCFM THEN
  2723.         Macro
  2724.         _LMSetOneOne         &src=(sp)+
  2725.         move.l               &src,$0A02
  2726.         EndM
  2727.     ELSE
  2728.         IMPORT_CFM_FUNCTION    LMSetOneOne
  2729.     ENDIF
  2730.  
  2731. ;
  2732. ; pascal SInt32 LMGetMinusOne(void)
  2733. ;
  2734.     IF ¬ GENERATINGCFM THEN
  2735.         Macro
  2736.         _LMGetMinusOne         &dest=(sp)
  2737.         move.l               $0A06,&dest
  2738.         EndM
  2739.     ELSE
  2740.         IMPORT_CFM_FUNCTION    LMGetMinusOne
  2741.     ENDIF
  2742.  
  2743. ;
  2744. ; pascal void LMSetMinusOne(SInt32 value)
  2745. ;
  2746.     IF ¬ GENERATINGCFM THEN
  2747.         Macro
  2748.         _LMSetMinusOne         &src=(sp)+
  2749.         move.l               &src,$0A06
  2750.         EndM
  2751.     ELSE
  2752.         IMPORT_CFM_FUNCTION    LMSetMinusOne
  2753.     ENDIF
  2754.  
  2755. ;
  2756. ; pascal SInt16 LMGetTopMenuItem(void)
  2757. ;
  2758.     IF ¬ GENERATINGCFM THEN
  2759.         Macro
  2760.         _LMGetTopMenuItem         &dest=(sp)
  2761.         move.w               $0A0A,&dest
  2762.         EndM
  2763.     ELSE
  2764.         IMPORT_CFM_FUNCTION    LMGetTopMenuItem
  2765.     ENDIF
  2766.  
  2767. ;
  2768. ; pascal void LMSetTopMenuItem(SInt16 value)
  2769. ;
  2770.     IF ¬ GENERATINGCFM THEN
  2771.         Macro
  2772.         _LMSetTopMenuItem         &src=(sp)+
  2773.         move.w               &src,$0A0A
  2774.         EndM
  2775.     ELSE
  2776.         IMPORT_CFM_FUNCTION    LMSetTopMenuItem
  2777.     ENDIF
  2778.  
  2779. ;
  2780. ; pascal SInt16 LMGetAtMenuBottom(void)
  2781. ;
  2782.     IF ¬ GENERATINGCFM THEN
  2783.         Macro
  2784.         _LMGetAtMenuBottom         &dest=(sp)
  2785.         move.w               $0A0C,&dest
  2786.         EndM
  2787.     ELSE
  2788.         IMPORT_CFM_FUNCTION    LMGetAtMenuBottom
  2789.     ENDIF
  2790.  
  2791. ;
  2792. ; pascal void LMSetAtMenuBottom(SInt16 value)
  2793. ;
  2794.     IF ¬ GENERATINGCFM THEN
  2795.         Macro
  2796.         _LMSetAtMenuBottom         &src=(sp)+
  2797.         move.w               &src,$0A0C
  2798.         EndM
  2799.     ELSE
  2800.         IMPORT_CFM_FUNCTION    LMSetAtMenuBottom
  2801.     ENDIF
  2802.  
  2803. ;
  2804. ; pascal Handle LMGetMenuList(void)
  2805. ;
  2806.     IF ¬ GENERATINGCFM THEN
  2807.         Macro
  2808.         _LMGetMenuList         &dest=(sp)
  2809.         move.l               $0A1C,&dest
  2810.         EndM
  2811.     ELSE
  2812.         IMPORT_CFM_FUNCTION    LMGetMenuList
  2813.     ENDIF
  2814.  
  2815. ;
  2816. ; pascal void LMSetMenuList(Handle value)
  2817. ;
  2818.     IF ¬ GENERATINGCFM THEN
  2819.         Macro
  2820.         _LMSetMenuList         &src=(sp)+
  2821.         move.l               &src,$0A1C
  2822.         EndM
  2823.     ELSE
  2824.         IMPORT_CFM_FUNCTION    LMSetMenuList
  2825.     ENDIF
  2826.  
  2827. ;
  2828. ; pascal SInt16 LMGetMBarEnable(void)
  2829. ;
  2830.     IF ¬ GENERATINGCFM THEN
  2831.         Macro
  2832.         _LMGetMBarEnable         &dest=(sp)
  2833.         move.w               $0A20,&dest
  2834.         EndM
  2835.     ELSE
  2836.         IMPORT_CFM_FUNCTION    LMGetMBarEnable
  2837.     ENDIF
  2838.  
  2839. ;
  2840. ; pascal void LMSetMBarEnable(SInt16 value)
  2841. ;
  2842.     IF ¬ GENERATINGCFM THEN
  2843.         Macro
  2844.         _LMSetMBarEnable         &src=(sp)+
  2845.         move.w               &src,$0A20
  2846.         EndM
  2847.     ELSE
  2848.         IMPORT_CFM_FUNCTION    LMSetMBarEnable
  2849.     ENDIF
  2850.  
  2851. ;
  2852. ; pascal SInt16 LMGetMenuFlash(void)
  2853. ;
  2854.     IF ¬ GENERATINGCFM THEN
  2855.         Macro
  2856.         _LMGetMenuFlash         &dest=(sp)
  2857.         move.w               $0A24,&dest
  2858.         EndM
  2859.     ELSE
  2860.         IMPORT_CFM_FUNCTION    LMGetMenuFlash
  2861.     ENDIF
  2862.  
  2863. ;
  2864. ; pascal void LMSetMenuFlash(SInt16 value)
  2865. ;
  2866.     IF ¬ GENERATINGCFM THEN
  2867.         Macro
  2868.         _LMSetMenuFlash         &src=(sp)+
  2869.         move.w               &src,$0A24
  2870.         EndM
  2871.     ELSE
  2872.         IMPORT_CFM_FUNCTION    LMSetMenuFlash
  2873.     ENDIF
  2874.  
  2875. ;
  2876. ; pascal SInt16 LMGetTheMenu(void)
  2877. ;
  2878.     IF ¬ GENERATINGCFM THEN
  2879.         Macro
  2880.         _LMGetTheMenu         &dest=(sp)
  2881.         move.w               $0A26,&dest
  2882.         EndM
  2883.     ELSE
  2884.         IMPORT_CFM_FUNCTION    LMGetTheMenu
  2885.     ENDIF
  2886.  
  2887. ;
  2888. ; pascal void LMSetTheMenu(SInt16 value)
  2889. ;
  2890.     IF ¬ GENERATINGCFM THEN
  2891.         Macro
  2892.         _LMSetTheMenu         &src=(sp)+
  2893.         move.w               &src,$0A26
  2894.         EndM
  2895.     ELSE
  2896.         IMPORT_CFM_FUNCTION    LMSetTheMenu
  2897.     ENDIF
  2898.  
  2899. ;
  2900. ; pascal UniversalProcPtr LMGetMBarHook(void)
  2901. ;
  2902.     IF ¬ GENERATINGCFM THEN
  2903.         Macro
  2904.         _LMGetMBarHook         &dest=(sp)
  2905.         move.l               $0A2C,&dest
  2906.         EndM
  2907.     ELSE
  2908.         IMPORT_CFM_FUNCTION    LMGetMBarHook
  2909.     ENDIF
  2910.  
  2911. ;
  2912. ; pascal void LMSetMBarHook(UniversalProcPtr value)
  2913. ;
  2914.     IF ¬ GENERATINGCFM THEN
  2915.         Macro
  2916.         _LMSetMBarHook         &src=(sp)+
  2917.         move.l               &src,$0A2C
  2918.         EndM
  2919.     ELSE
  2920.         IMPORT_CFM_FUNCTION    LMSetMBarHook
  2921.     ENDIF
  2922.  
  2923. ;
  2924. ; pascal UniversalProcPtr LMGetMenuHook(void)
  2925. ;
  2926.     IF ¬ GENERATINGCFM THEN
  2927.         Macro
  2928.         _LMGetMenuHook         &dest=(sp)
  2929.         move.l               $0A30,&dest
  2930.         EndM
  2931.     ELSE
  2932.         IMPORT_CFM_FUNCTION    LMGetMenuHook
  2933.     ENDIF
  2934.  
  2935. ;
  2936. ; pascal void LMSetMenuHook(UniversalProcPtr value)
  2937. ;
  2938.     IF ¬ GENERATINGCFM THEN
  2939.         Macro
  2940.         _LMSetMenuHook         &src=(sp)+
  2941.         move.l               &src,$0A30
  2942.         EndM
  2943.     ELSE
  2944.         IMPORT_CFM_FUNCTION    LMSetMenuHook
  2945.     ENDIF
  2946.  
  2947. ;
  2948. ; pascal Handle LMGetTopMapHndl(void)
  2949. ;
  2950.     IF ¬ GENERATINGCFM THEN
  2951.         Macro
  2952.         _LMGetTopMapHndl         &dest=(sp)
  2953.         move.l               $0A50,&dest
  2954.         EndM
  2955.     ELSE
  2956.         IMPORT_CFM_FUNCTION    LMGetTopMapHndl
  2957.     ENDIF
  2958.  
  2959. ;
  2960. ; pascal void LMSetTopMapHndl(Handle value)
  2961. ;
  2962.     IF ¬ GENERATINGCFM THEN
  2963.         Macro
  2964.         _LMSetTopMapHndl         &src=(sp)+
  2965.         move.l               &src,$0A50
  2966.         EndM
  2967.     ELSE
  2968.         IMPORT_CFM_FUNCTION    LMSetTopMapHndl
  2969.     ENDIF
  2970.  
  2971. ;
  2972. ; pascal Handle LMGetSysMapHndl(void)
  2973. ;
  2974.     IF ¬ GENERATINGCFM THEN
  2975.         Macro
  2976.         _LMGetSysMapHndl         &dest=(sp)
  2977.         move.l               $0A54,&dest
  2978.         EndM
  2979.     ELSE
  2980.         IMPORT_CFM_FUNCTION    LMGetSysMapHndl
  2981.     ENDIF
  2982.  
  2983. ;
  2984. ; pascal void LMSetSysMapHndl(Handle value)
  2985. ;
  2986.     IF ¬ GENERATINGCFM THEN
  2987.         Macro
  2988.         _LMSetSysMapHndl         &src=(sp)+
  2989.         move.l               &src,$0A54
  2990.         EndM
  2991.     ELSE
  2992.         IMPORT_CFM_FUNCTION    LMSetSysMapHndl
  2993.     ENDIF
  2994.  
  2995. ;
  2996. ; pascal SInt16 LMGetSysMap(void)
  2997. ;
  2998.     IF ¬ GENERATINGCFM THEN
  2999.         Macro
  3000.         _LMGetSysMap         &dest=(sp)
  3001.         move.w               $0A58,&dest
  3002.         EndM
  3003.     ELSE
  3004.         IMPORT_CFM_FUNCTION    LMGetSysMap
  3005.     ENDIF
  3006.  
  3007. ;
  3008. ; pascal void LMSetSysMap(SInt16 value)
  3009. ;
  3010.     IF ¬ GENERATINGCFM THEN
  3011.         Macro
  3012.         _LMSetSysMap         &src=(sp)+
  3013.         move.w               &src,$0A58
  3014.         EndM
  3015.     ELSE
  3016.         IMPORT_CFM_FUNCTION    LMSetSysMap
  3017.     ENDIF
  3018.  
  3019. ;
  3020. ; pascal SInt16 LMGetCurMap(void)
  3021. ;
  3022.     IF ¬ GENERATINGCFM THEN
  3023.         Macro
  3024.         _LMGetCurMap         &dest=(sp)
  3025.         move.w               $0A5A,&dest
  3026.         EndM
  3027.     ELSE
  3028.         IMPORT_CFM_FUNCTION    LMGetCurMap
  3029.     ENDIF
  3030.  
  3031. ;
  3032. ; pascal void LMSetCurMap(SInt16 value)
  3033. ;
  3034.     IF ¬ GENERATINGCFM THEN
  3035.         Macro
  3036.         _LMSetCurMap         &src=(sp)+
  3037.         move.w               &src,$0A5A
  3038.         EndM
  3039.     ELSE
  3040.         IMPORT_CFM_FUNCTION    LMSetCurMap
  3041.     ENDIF
  3042.  
  3043. ;
  3044. ; pascal UInt8 LMGetResLoad(void)
  3045. ;
  3046.     IF ¬ GENERATINGCFM THEN
  3047.         Macro
  3048.         _LMGetResLoad         &dest=(sp)
  3049.         move.b               $0A5E,&dest
  3050.         EndM
  3051.     ELSE
  3052.         IMPORT_CFM_FUNCTION    LMGetResLoad
  3053.     ENDIF
  3054.  
  3055. ;
  3056. ; pascal void LMSetResLoad(UInt8 value)
  3057. ;
  3058.     IF ¬ GENERATINGCFM THEN
  3059.         Macro
  3060.         _LMSetResLoad         &src=(sp)+
  3061.         move.b               &src,$0A5E
  3062.         EndM
  3063.     ELSE
  3064.         IMPORT_CFM_FUNCTION    LMSetResLoad
  3065.     ENDIF
  3066.  
  3067. ;
  3068. ; pascal SInt16 LMGetResErr(void)
  3069. ;
  3070.     IF ¬ GENERATINGCFM THEN
  3071.         Macro
  3072.         _LMGetResErr         &dest=(sp)
  3073.         move.w               $0A60,&dest
  3074.         EndM
  3075.     ELSE
  3076.         IMPORT_CFM_FUNCTION    LMGetResErr
  3077.     ENDIF
  3078.  
  3079. ;
  3080. ; pascal void LMSetResErr(SInt16 value)
  3081. ;
  3082.     IF ¬ GENERATINGCFM THEN
  3083.         Macro
  3084.         _LMSetResErr         &src=(sp)+
  3085.         move.w               &src,$0A60
  3086.         EndM
  3087.     ELSE
  3088.         IMPORT_CFM_FUNCTION    LMSetResErr
  3089.     ENDIF
  3090.  
  3091. ;
  3092. ; pascal UInt8 LMGetFScaleDisable(void)
  3093. ;
  3094.     IF ¬ GENERATINGCFM THEN
  3095.         Macro
  3096.         _LMGetFScaleDisable         &dest=(sp)
  3097.         move.b               $0A63,&dest
  3098.         EndM
  3099.     ELSE
  3100.         IMPORT_CFM_FUNCTION    LMGetFScaleDisable
  3101.     ENDIF
  3102.  
  3103. ;
  3104. ; pascal void LMSetFScaleDisable(UInt8 value)
  3105. ;
  3106.     IF ¬ GENERATINGCFM THEN
  3107.         Macro
  3108.         _LMSetFScaleDisable         &src=(sp)+
  3109.         move.b               &src,$0A63
  3110.         EndM
  3111.     ELSE
  3112.         IMPORT_CFM_FUNCTION    LMSetFScaleDisable
  3113.     ENDIF
  3114.  
  3115. ;
  3116. ; pascal UniversalProcPtr LMGetDeskHook(void)
  3117. ;
  3118.     IF ¬ GENERATINGCFM THEN
  3119.         Macro
  3120.         _LMGetDeskHook         &dest=(sp)
  3121.         move.l               $0A6C,&dest
  3122.         EndM
  3123.     ELSE
  3124.         IMPORT_CFM_FUNCTION    LMGetDeskHook
  3125.     ENDIF
  3126.  
  3127. ;
  3128. ; pascal void LMSetDeskHook(UniversalProcPtr value)
  3129. ;
  3130.     IF ¬ GENERATINGCFM THEN
  3131.         Macro
  3132.         _LMSetDeskHook         &src=(sp)+
  3133.         move.l               &src,$0A6C
  3134.         EndM
  3135.     ELSE
  3136.         IMPORT_CFM_FUNCTION    LMSetDeskHook
  3137.     ENDIF
  3138.  
  3139. ;
  3140. ; pascal UniversalProcPtr LMGetTEDoText(void)
  3141. ;
  3142.     IF ¬ GENERATINGCFM THEN
  3143.         Macro
  3144.         _LMGetTEDoText         &dest=(sp)
  3145.         move.l               $0A70,&dest
  3146.         EndM
  3147.     ELSE
  3148.         IMPORT_CFM_FUNCTION    LMGetTEDoText
  3149.     ENDIF
  3150.  
  3151. ;
  3152. ; pascal void LMSetTEDoText(UniversalProcPtr value)
  3153. ;
  3154.     IF ¬ GENERATINGCFM THEN
  3155.         Macro
  3156.         _LMSetTEDoText         &src=(sp)+
  3157.         move.l               &src,$0A70
  3158.         EndM
  3159.     ELSE
  3160.         IMPORT_CFM_FUNCTION    LMSetTEDoText
  3161.     ENDIF
  3162.  
  3163. ;
  3164. ; pascal UniversalProcPtr LMGetTERecal(void)
  3165. ;
  3166.     IF ¬ GENERATINGCFM THEN
  3167.         Macro
  3168.         _LMGetTERecal         &dest=(sp)
  3169.         move.l               $0A74,&dest
  3170.         EndM
  3171.     ELSE
  3172.         IMPORT_CFM_FUNCTION    LMGetTERecal
  3173.     ENDIF
  3174.  
  3175. ;
  3176. ; pascal void LMSetTERecal(UniversalProcPtr value)
  3177. ;
  3178.     IF ¬ GENERATINGCFM THEN
  3179.         Macro
  3180.         _LMSetTERecal         &src=(sp)+
  3181.         move.l               &src,$0A74
  3182.         EndM
  3183.     ELSE
  3184.         IMPORT_CFM_FUNCTION    LMSetTERecal
  3185.     ENDIF
  3186.  
  3187. ;
  3188. ; pascal UniversalProcPtr LMGetResumeProc(void)
  3189. ;
  3190.     IF ¬ GENERATINGCFM THEN
  3191.         Macro
  3192.         _LMGetResumeProc         &dest=(sp)
  3193.         move.l               $0A8C,&dest
  3194.         EndM
  3195.     ELSE
  3196.         IMPORT_CFM_FUNCTION    LMGetResumeProc
  3197.     ENDIF
  3198.  
  3199. ;
  3200. ; pascal void LMSetResumeProc(UniversalProcPtr value)
  3201. ;
  3202.     IF ¬ GENERATINGCFM THEN
  3203.         Macro
  3204.         _LMSetResumeProc         &src=(sp)+
  3205.         move.l               &src,$0A8C
  3206.         EndM
  3207.     ELSE
  3208.         IMPORT_CFM_FUNCTION    LMSetResumeProc
  3209.     ENDIF
  3210.  
  3211. ;
  3212. ; pascal SInt16 LMGetANumber(void)
  3213. ;
  3214.     IF ¬ GENERATINGCFM THEN
  3215.         Macro
  3216.         _LMGetANumber         &dest=(sp)
  3217.         move.w               $0A98,&dest
  3218.         EndM
  3219.     ELSE
  3220.         IMPORT_CFM_FUNCTION    LMGetANumber
  3221.     ENDIF
  3222.  
  3223. ;
  3224. ; pascal void LMSetANumber(SInt16 value)
  3225. ;
  3226.     IF ¬ GENERATINGCFM THEN
  3227.         Macro
  3228.         _LMSetANumber         &src=(sp)+
  3229.         move.w               &src,$0A98
  3230.         EndM
  3231.     ELSE
  3232.         IMPORT_CFM_FUNCTION    LMSetANumber
  3233.     ENDIF
  3234.  
  3235. ;
  3236. ; pascal SInt16 LMGetACount(void)
  3237. ;
  3238.     IF ¬ GENERATINGCFM THEN
  3239.         Macro
  3240.         _LMGetACount         &dest=(sp)
  3241.         move.w               $0A9A,&dest
  3242.         EndM
  3243.     ELSE
  3244.         IMPORT_CFM_FUNCTION    LMGetACount
  3245.     ENDIF
  3246.  
  3247. ;
  3248. ; pascal void LMSetACount(SInt16 value)
  3249. ;
  3250.     IF ¬ GENERATINGCFM THEN
  3251.         Macro
  3252.         _LMSetACount         &src=(sp)+
  3253.         move.w               &src,$0A9A
  3254.         EndM
  3255.     ELSE
  3256.         IMPORT_CFM_FUNCTION    LMSetACount
  3257.     ENDIF
  3258.  
  3259. ;
  3260. ; pascal UniversalProcPtr LMGetDABeeper(void)
  3261. ;
  3262.     IF ¬ GENERATINGCFM THEN
  3263.         Macro
  3264.         _LMGetDABeeper         &dest=(sp)
  3265.         move.l               $0A9C,&dest
  3266.         EndM
  3267.     ELSE
  3268.         IMPORT_CFM_FUNCTION    LMGetDABeeper
  3269.     ENDIF
  3270.  
  3271. ;
  3272. ; pascal void LMSetDABeeper(UniversalProcPtr value)
  3273. ;
  3274.     IF ¬ GENERATINGCFM THEN
  3275.         Macro
  3276.         _LMSetDABeeper         &src=(sp)+
  3277.         move.l               &src,$0A9C
  3278.         EndM
  3279.     ELSE
  3280.         IMPORT_CFM_FUNCTION    LMSetDABeeper
  3281.     ENDIF
  3282.  
  3283. ;
  3284. ; pascal UInt16 LMGetTEScrpLength(void)
  3285. ;
  3286.     IF ¬ GENERATINGCFM THEN
  3287.         Macro
  3288.         _LMGetTEScrpLength         &dest=(sp)
  3289.         move.w               $0AB0,&dest
  3290.         EndM
  3291.     ELSE
  3292.         IMPORT_CFM_FUNCTION    LMGetTEScrpLength
  3293.     ENDIF
  3294.  
  3295. ;
  3296. ; pascal void LMSetTEScrpLength(UInt16 value)
  3297. ;
  3298.     IF ¬ GENERATINGCFM THEN
  3299.         Macro
  3300.         _LMSetTEScrpLength         &src=(sp)+
  3301.         move.w               &src,$0AB0
  3302.         EndM
  3303.     ELSE
  3304.         IMPORT_CFM_FUNCTION    LMSetTEScrpLength
  3305.     ENDIF
  3306.  
  3307. ;
  3308. ; pascal Handle LMGetTEScrpHandle(void)
  3309. ;
  3310.     IF ¬ GENERATINGCFM THEN
  3311.         Macro
  3312.         _LMGetTEScrpHandle         &dest=(sp)
  3313.         move.l               $0AB4,&dest
  3314.         EndM
  3315.     ELSE
  3316.         IMPORT_CFM_FUNCTION    LMGetTEScrpHandle
  3317.     ENDIF
  3318.  
  3319. ;
  3320. ; pascal void LMSetTEScrpHandle(Handle value)
  3321. ;
  3322.     IF ¬ GENERATINGCFM THEN
  3323.         Macro
  3324.         _LMSetTEScrpHandle         &src=(sp)+
  3325.         move.l               &src,$0AB4
  3326.         EndM
  3327.     ELSE
  3328.         IMPORT_CFM_FUNCTION    LMSetTEScrpHandle
  3329.     ENDIF
  3330.  
  3331. ;
  3332. ; pascal Handle LMGetAppParmHandle(void)
  3333. ;
  3334.     IF ¬ GENERATINGCFM THEN
  3335.         Macro
  3336.         _LMGetAppParmHandle         &dest=(sp)
  3337.         move.l               $0AEC,&dest
  3338.         EndM
  3339.     ELSE
  3340.         IMPORT_CFM_FUNCTION    LMGetAppParmHandle
  3341.     ENDIF
  3342.  
  3343. ;
  3344. ; pascal void LMSetAppParmHandle(Handle value)
  3345. ;
  3346.     IF ¬ GENERATINGCFM THEN
  3347.         Macro
  3348.         _LMSetAppParmHandle         &src=(sp)+
  3349.         move.l               &src,$0AEC
  3350.         EndM
  3351.     ELSE
  3352.         IMPORT_CFM_FUNCTION    LMSetAppParmHandle
  3353.     ENDIF
  3354.  
  3355. ;
  3356. ; pascal SInt16 LMGetDSErrCode(void)
  3357. ;
  3358.     IF ¬ GENERATINGCFM THEN
  3359.         Macro
  3360.         _LMGetDSErrCode         &dest=(sp)
  3361.         move.w               $0AF0,&dest
  3362.         EndM
  3363.     ELSE
  3364.         IMPORT_CFM_FUNCTION    LMGetDSErrCode
  3365.     ENDIF
  3366.  
  3367. ;
  3368. ; pascal void LMSetDSErrCode(SInt16 value)
  3369. ;
  3370.     IF ¬ GENERATINGCFM THEN
  3371.         Macro
  3372.         _LMSetDSErrCode         &src=(sp)+
  3373.         move.w               &src,$0AF0
  3374.         EndM
  3375.     ELSE
  3376.         IMPORT_CFM_FUNCTION    LMSetDSErrCode
  3377.     ENDIF
  3378.  
  3379. ;
  3380. ; pascal ResErrUPP LMGetResErrProc(void)
  3381. ;
  3382.     IF ¬ GENERATINGCFM THEN
  3383.         Macro
  3384.         _LMGetResErrProc         &dest=(sp)
  3385.         move.l               $0AF2,&dest
  3386.         EndM
  3387.     ELSE
  3388.         IMPORT_CFM_FUNCTION    LMGetResErrProc
  3389.     ENDIF
  3390.  
  3391. ;
  3392. ; pascal void LMSetResErrProc(ResErrUPP value)
  3393. ;
  3394.     IF ¬ GENERATINGCFM THEN
  3395.         Macro
  3396.         _LMSetResErrProc         &src=(sp)+
  3397.         move.l               &src,$0AF2
  3398.         EndM
  3399.     ELSE
  3400.         IMPORT_CFM_FUNCTION    LMSetResErrProc
  3401.     ENDIF
  3402.  
  3403. ;
  3404. ; pascal SInt16 LMGetDlgFont(void)
  3405. ;
  3406.     IF ¬ GENERATINGCFM THEN
  3407.         Macro
  3408.         _LMGetDlgFont         &dest=(sp)
  3409.         move.w               $0AFA,&dest
  3410.         EndM
  3411.     ELSE
  3412.         IMPORT_CFM_FUNCTION    LMGetDlgFont
  3413.     ENDIF
  3414.  
  3415. ;
  3416. ; pascal void LMSetDlgFont(SInt16 value)
  3417. ;
  3418.     IF ¬ GENERATINGCFM THEN
  3419.         Macro
  3420.         _LMSetDlgFont         &src=(sp)+
  3421.         move.w               &src,$0AFA
  3422.         EndM
  3423.     ELSE
  3424.         IMPORT_CFM_FUNCTION    LMSetDlgFont
  3425.     ENDIF
  3426.  
  3427. ;
  3428. ; pascal Ptr LMGetWidthPtr(void)
  3429. ;
  3430.     IF ¬ GENERATINGCFM THEN
  3431.         Macro
  3432.         _LMGetWidthPtr         &dest=(sp)
  3433.         move.l               $0B10,&dest
  3434.         EndM
  3435.     ELSE
  3436.         IMPORT_CFM_FUNCTION    LMGetWidthPtr
  3437.     ENDIF
  3438.  
  3439. ;
  3440. ; pascal void LMSetWidthPtr(Ptr value)
  3441. ;
  3442.     IF ¬ GENERATINGCFM THEN
  3443.         Macro
  3444.         _LMSetWidthPtr         &src=(sp)+
  3445.         move.l               &src,$0B10
  3446.         EndM
  3447.     ELSE
  3448.         IMPORT_CFM_FUNCTION    LMSetWidthPtr
  3449.     ENDIF
  3450.  
  3451. ;
  3452. ; pascal Ptr LMGetATalkHk2(void)
  3453. ;
  3454.     IF ¬ GENERATINGCFM THEN
  3455.         Macro
  3456.         _LMGetATalkHk2         &dest=(sp)
  3457.         move.l               $0B18,&dest
  3458.         EndM
  3459.     ELSE
  3460.         IMPORT_CFM_FUNCTION    LMGetATalkHk2
  3461.     ENDIF
  3462.  
  3463. ;
  3464. ; pascal void LMSetATalkHk2(Ptr value)
  3465. ;
  3466.     IF ¬ GENERATINGCFM THEN
  3467.         Macro
  3468.         _LMSetATalkHk2         &src=(sp)+
  3469.         move.l               &src,$0B18
  3470.         EndM
  3471.     ELSE
  3472.         IMPORT_CFM_FUNCTION    LMSetATalkHk2
  3473.     ENDIF
  3474.  
  3475. ;
  3476. ; pascal SInt16 LMGetHWCfgFlags(void)
  3477. ;
  3478.     IF ¬ GENERATINGCFM THEN
  3479.         Macro
  3480.         _LMGetHWCfgFlags         &dest=(sp)
  3481.         move.w               $0B22,&dest
  3482.         EndM
  3483.     ELSE
  3484.         IMPORT_CFM_FUNCTION    LMGetHWCfgFlags
  3485.     ENDIF
  3486.  
  3487. ;
  3488. ; pascal void LMSetHWCfgFlags(SInt16 value)
  3489. ;
  3490.     IF ¬ GENERATINGCFM THEN
  3491.         Macro
  3492.         _LMSetHWCfgFlags         &src=(sp)+
  3493.         move.w               &src,$0B22
  3494.         EndM
  3495.     ELSE
  3496.         IMPORT_CFM_FUNCTION    LMSetHWCfgFlags
  3497.     ENDIF
  3498.  
  3499. ;
  3500. ; pascal Handle LMGetWidthTabHandle(void)
  3501. ;
  3502.     IF ¬ GENERATINGCFM THEN
  3503.         Macro
  3504.         _LMGetWidthTabHandle         &dest=(sp)
  3505.         move.l               $0B2A,&dest
  3506.         EndM
  3507.     ELSE
  3508.         IMPORT_CFM_FUNCTION    LMGetWidthTabHandle
  3509.     ENDIF
  3510.  
  3511. ;
  3512. ; pascal void LMSetWidthTabHandle(Handle value)
  3513. ;
  3514.     IF ¬ GENERATINGCFM THEN
  3515.         Macro
  3516.         _LMSetWidthTabHandle         &src=(sp)+
  3517.         move.l               &src,$0B2A
  3518.         EndM
  3519.     ELSE
  3520.         IMPORT_CFM_FUNCTION    LMSetWidthTabHandle
  3521.     ENDIF
  3522.  
  3523. ;
  3524. ; pascal SInt32 LMGetLastSPExtra(void)
  3525. ;
  3526.     IF ¬ GENERATINGCFM THEN
  3527.         Macro
  3528.         _LMGetLastSPExtra         &dest=(sp)
  3529.         move.l               $0B4C,&dest
  3530.         EndM
  3531.     ELSE
  3532.         IMPORT_CFM_FUNCTION    LMGetLastSPExtra
  3533.     ENDIF
  3534.  
  3535. ;
  3536. ; pascal void LMSetLastSPExtra(SInt32 value)
  3537. ;
  3538.     IF ¬ GENERATINGCFM THEN
  3539.         Macro
  3540.         _LMSetLastSPExtra         &src=(sp)+
  3541.         move.l               &src,$0B4C
  3542.         EndM
  3543.     ELSE
  3544.         IMPORT_CFM_FUNCTION    LMSetLastSPExtra
  3545.     ENDIF
  3546.  
  3547. ;
  3548. ; pascal SInt32 LMGetMenuDisable(void)
  3549. ;
  3550.     IF ¬ GENERATINGCFM THEN
  3551.         Macro
  3552.         _LMGetMenuDisable         &dest=(sp)
  3553.         move.l               $0B54,&dest
  3554.         EndM
  3555.     ELSE
  3556.         IMPORT_CFM_FUNCTION    LMGetMenuDisable
  3557.     ENDIF
  3558.  
  3559. ;
  3560. ; pascal void LMSetMenuDisable(SInt32 value)
  3561. ;
  3562.     IF ¬ GENERATINGCFM THEN
  3563.         Macro
  3564.         _LMSetMenuDisable         &src=(sp)+
  3565.         move.l               &src,$0B54
  3566.         EndM
  3567.     ELSE
  3568.         IMPORT_CFM_FUNCTION    LMSetMenuDisable
  3569.     ENDIF
  3570.  
  3571. ;
  3572. ; pascal UInt8 LMGetROMMapInsert(void)
  3573. ;
  3574.     IF ¬ GENERATINGCFM THEN
  3575.         Macro
  3576.         _LMGetROMMapInsert         &dest=(sp)
  3577.         move.b               $0B9E,&dest
  3578.         EndM
  3579.     ELSE
  3580.         IMPORT_CFM_FUNCTION    LMGetROMMapInsert
  3581.     ENDIF
  3582.  
  3583. ;
  3584. ; pascal void LMSetROMMapInsert(UInt8 value)
  3585. ;
  3586.     IF ¬ GENERATINGCFM THEN
  3587.         Macro
  3588.         _LMSetROMMapInsert         &src=(sp)+
  3589.         move.b               &src,$0B9E
  3590.         EndM
  3591.     ELSE
  3592.         IMPORT_CFM_FUNCTION    LMSetROMMapInsert
  3593.     ENDIF
  3594.  
  3595. ;
  3596. ; pascal UInt8 LMGetTmpResLoad(void)
  3597. ;
  3598.     IF ¬ GENERATINGCFM THEN
  3599.         Macro
  3600.         _LMGetTmpResLoad         &dest=(sp)
  3601.         move.b               $0B9F,&dest
  3602.         EndM
  3603.     ELSE
  3604.         IMPORT_CFM_FUNCTION    LMGetTmpResLoad
  3605.     ENDIF
  3606.  
  3607. ;
  3608. ; pascal void LMSetTmpResLoad(UInt8 value)
  3609. ;
  3610.     IF ¬ GENERATINGCFM THEN
  3611.         Macro
  3612.         _LMSetTmpResLoad         &src=(sp)+
  3613.         move.b               &src,$0B9F
  3614.         EndM
  3615.     ELSE
  3616.         IMPORT_CFM_FUNCTION    LMSetTmpResLoad
  3617.     ENDIF
  3618.  
  3619. ;
  3620. ; pascal Ptr LMGetIntlSpec(void)
  3621. ;
  3622.     IF ¬ GENERATINGCFM THEN
  3623.         Macro
  3624.         _LMGetIntlSpec         &dest=(sp)
  3625.         move.l               $0BA0,&dest
  3626.         EndM
  3627.     ELSE
  3628.         IMPORT_CFM_FUNCTION    LMGetIntlSpec
  3629.     ENDIF
  3630.  
  3631. ;
  3632. ; pascal void LMSetIntlSpec(Ptr value)
  3633. ;
  3634.     IF ¬ GENERATINGCFM THEN
  3635.         Macro
  3636.         _LMSetIntlSpec         &src=(sp)+
  3637.         move.l               &src,$0BA0
  3638.         EndM
  3639.     ELSE
  3640.         IMPORT_CFM_FUNCTION    LMSetIntlSpec
  3641.     ENDIF
  3642.  
  3643. ;
  3644. ; pascal UInt8 LMGetWordRedraw(void)
  3645. ;
  3646.     IF ¬ GENERATINGCFM THEN
  3647.         Macro
  3648.         _LMGetWordRedraw         &dest=(sp)
  3649.         move.b               $0BA5,&dest
  3650.         EndM
  3651.     ELSE
  3652.         IMPORT_CFM_FUNCTION    LMGetWordRedraw
  3653.     ENDIF
  3654.  
  3655. ;
  3656. ; pascal void LMSetWordRedraw(UInt8 value)
  3657. ;
  3658.     IF ¬ GENERATINGCFM THEN
  3659.         Macro
  3660.         _LMSetWordRedraw         &src=(sp)+
  3661.         move.b               &src,$0BA5
  3662.         EndM
  3663.     ELSE
  3664.         IMPORT_CFM_FUNCTION    LMSetWordRedraw
  3665.     ENDIF
  3666.  
  3667. ;
  3668. ; pascal SInt16 LMGetSysFontFam(void)
  3669. ;
  3670.     IF ¬ GENERATINGCFM THEN
  3671.         Macro
  3672.         _LMGetSysFontFam         &dest=(sp)
  3673.         move.w               $0BA6,&dest
  3674.         EndM
  3675.     ELSE
  3676.         IMPORT_CFM_FUNCTION    LMGetSysFontFam
  3677.     ENDIF
  3678.  
  3679. ;
  3680. ; pascal void LMSetSysFontFam(SInt16 value)
  3681. ;
  3682.     IF ¬ GENERATINGCFM THEN
  3683.         Macro
  3684.         _LMSetSysFontFam         &src=(sp)+
  3685.         move.w               &src,$0BA6
  3686.         EndM
  3687.     ELSE
  3688.         IMPORT_CFM_FUNCTION    LMSetSysFontFam
  3689.     ENDIF
  3690.  
  3691. ;
  3692. ; pascal SInt16 LMGetSysFontSize(void)
  3693. ;
  3694.     IF ¬ GENERATINGCFM THEN
  3695.         Macro
  3696.         _LMGetSysFontSize         &dest=(sp)
  3697.         move.w               $0BA8,&dest
  3698.         EndM
  3699.     ELSE
  3700.         IMPORT_CFM_FUNCTION    LMGetSysFontSize
  3701.     ENDIF
  3702.  
  3703. ;
  3704. ; pascal void LMSetSysFontSize(SInt16 value)
  3705. ;
  3706.     IF ¬ GENERATINGCFM THEN
  3707.         Macro
  3708.         _LMSetSysFontSize         &src=(sp)+
  3709.         move.w               &src,$0BA8
  3710.         EndM
  3711.     ELSE
  3712.         IMPORT_CFM_FUNCTION    LMSetSysFontSize
  3713.     ENDIF
  3714.  
  3715. ;
  3716. ; pascal SInt16 LMGetMBarHeight(void)
  3717. ;
  3718.     IF ¬ GENERATINGCFM THEN
  3719.         Macro
  3720.         _LMGetMBarHeight         &dest=(sp)
  3721.         move.w               $0BAA,&dest
  3722.         EndM
  3723.     ELSE
  3724.         IMPORT_CFM_FUNCTION    LMGetMBarHeight
  3725.     ENDIF
  3726.  
  3727. ;
  3728. ; pascal void LMSetMBarHeight(SInt16 value)
  3729. ;
  3730.     IF ¬ GENERATINGCFM THEN
  3731.         Macro
  3732.         _LMSetMBarHeight         &src=(sp)+
  3733.         move.w               &src,$0BAA
  3734.         EndM
  3735.     ELSE
  3736.         IMPORT_CFM_FUNCTION    LMSetMBarHeight
  3737.     ENDIF
  3738.  
  3739. ;
  3740. ; pascal SInt16 LMGetTESysJust(void)
  3741. ;
  3742.     IF ¬ GENERATINGCFM THEN
  3743.         Macro
  3744.         _LMGetTESysJust         &dest=(sp)
  3745.         move.w               $0BAC,&dest
  3746.         EndM
  3747.     ELSE
  3748.         IMPORT_CFM_FUNCTION    LMGetTESysJust
  3749.     ENDIF
  3750.  
  3751. ;
  3752. ; pascal void LMSetTESysJust(SInt16 value)
  3753. ;
  3754.     IF ¬ GENERATINGCFM THEN
  3755.         Macro
  3756.         _LMSetTESysJust         &src=(sp)+
  3757.         move.w               &src,$0BAC
  3758.         EndM
  3759.     ELSE
  3760.         IMPORT_CFM_FUNCTION    LMSetTESysJust
  3761.     ENDIF
  3762.  
  3763. ;
  3764. ; pascal Handle LMGetLastFOND(void)
  3765. ;
  3766.     IF ¬ GENERATINGCFM THEN
  3767.         Macro
  3768.         _LMGetLastFOND         &dest=(sp)
  3769.         move.l               $0BC2,&dest
  3770.         EndM
  3771.     ELSE
  3772.         IMPORT_CFM_FUNCTION    LMGetLastFOND
  3773.     ENDIF
  3774.  
  3775. ;
  3776. ; pascal void LMSetLastFOND(Handle value)
  3777. ;
  3778.     IF ¬ GENERATINGCFM THEN
  3779.         Macro
  3780.         _LMSetLastFOND         &src=(sp)+
  3781.         move.l               &src,$0BC2
  3782.         EndM
  3783.     ELSE
  3784.         IMPORT_CFM_FUNCTION    LMSetLastFOND
  3785.     ENDIF
  3786.  
  3787. ;
  3788. ; pascal UInt8 LMGetFractEnable(void)
  3789. ;
  3790.     IF ¬ GENERATINGCFM THEN
  3791.         Macro
  3792.         _LMGetFractEnable         &dest=(sp)
  3793.         move.b               $0BF4,&dest
  3794.         EndM
  3795.     ELSE
  3796.         IMPORT_CFM_FUNCTION    LMGetFractEnable
  3797.     ENDIF
  3798.  
  3799. ;
  3800. ; pascal void LMSetFractEnable(UInt8 value)
  3801. ;
  3802.     IF ¬ GENERATINGCFM THEN
  3803.         Macro
  3804.         _LMSetFractEnable         &src=(sp)+
  3805.         move.b               &src,$0BF4
  3806.         EndM
  3807.     ELSE
  3808.         IMPORT_CFM_FUNCTION    LMSetFractEnable
  3809.     ENDIF
  3810.  
  3811. ;
  3812. ; pascal UInt8 LMGetMMU32Bit(void)
  3813. ;
  3814.     IF ¬ GENERATINGCFM THEN
  3815.         Macro
  3816.         _LMGetMMU32Bit         &dest=(sp)
  3817.         move.b               $0CB2,&dest
  3818.         EndM
  3819.     ELSE
  3820.         IMPORT_CFM_FUNCTION    LMGetMMU32Bit
  3821.     ENDIF
  3822.  
  3823. ;
  3824. ; pascal void LMSetMMU32Bit(UInt8 value)
  3825. ;
  3826.     IF ¬ GENERATINGCFM THEN
  3827.         Macro
  3828.         _LMSetMMU32Bit         &src=(sp)+
  3829.         move.b               &src,$0CB2
  3830.         EndM
  3831.     ELSE
  3832.         IMPORT_CFM_FUNCTION    LMSetMMU32Bit
  3833.     ENDIF
  3834.  
  3835. ;
  3836. ; pascal GDHandle LMGetTheGDevice(void)
  3837. ;
  3838.     IF ¬ GENERATINGCFM THEN
  3839.         Macro
  3840.         _LMGetTheGDevice         &dest=(sp)
  3841.         move.l               $0CC8,&dest
  3842.         EndM
  3843.     ELSE
  3844.         IMPORT_CFM_FUNCTION    LMGetTheGDevice
  3845.     ENDIF
  3846.  
  3847. ;
  3848. ; pascal void LMSetTheGDevice(GDHandle value)
  3849. ;
  3850.     IF ¬ GENERATINGCFM THEN
  3851.         Macro
  3852.         _LMSetTheGDevice         &src=(sp)+
  3853.         move.l               &src,$0CC8
  3854.         EndM
  3855.     ELSE
  3856.         IMPORT_CFM_FUNCTION    LMSetTheGDevice
  3857.     ENDIF
  3858.  
  3859. ;
  3860. ; pascal PixPatHandle LMGetDeskCPat(void)
  3861. ;
  3862.     IF ¬ GENERATINGCFM THEN
  3863.         Macro
  3864.         _LMGetDeskCPat         &dest=(sp)
  3865.         move.l               $0CD8,&dest
  3866.         EndM
  3867.     ELSE
  3868.         IMPORT_CFM_FUNCTION    LMGetDeskCPat
  3869.     ENDIF
  3870.  
  3871. ;
  3872. ; pascal void LMSetDeskCPat(PixPatHandle value)
  3873. ;
  3874.     IF ¬ GENERATINGCFM THEN
  3875.         Macro
  3876.         _LMSetDeskCPat         &src=(sp)+
  3877.         move.l               &src,$0CD8
  3878.         EndM
  3879.     ELSE
  3880.         IMPORT_CFM_FUNCTION    LMSetDeskCPat
  3881.     ENDIF
  3882.  
  3883. ;
  3884. ; pascal SInt16 LMGetTimeDBRA(void)
  3885. ;
  3886.     IF ¬ GENERATINGCFM THEN
  3887.         Macro
  3888.         _LMGetTimeDBRA         &dest=(sp)
  3889.         move.w               $0D00,&dest
  3890.         EndM
  3891.     ELSE
  3892.         IMPORT_CFM_FUNCTION    LMGetTimeDBRA
  3893.     ENDIF
  3894.  
  3895. ;
  3896. ; pascal void LMSetTimeDBRA(SInt16 value)
  3897. ;
  3898.     IF ¬ GENERATINGCFM THEN
  3899.         Macro
  3900.         _LMSetTimeDBRA         &src=(sp)+
  3901.         move.w               &src,$0D00
  3902.         EndM
  3903.     ELSE
  3904.         IMPORT_CFM_FUNCTION    LMSetTimeDBRA
  3905.     ENDIF
  3906.  
  3907. ;
  3908. ; pascal SInt16 LMGetTimeSCCDB(void)
  3909. ;
  3910.     IF ¬ GENERATINGCFM THEN
  3911.         Macro
  3912.         _LMGetTimeSCCDB         &dest=(sp)
  3913.         move.w               $0D02,&dest
  3914.         EndM
  3915.     ELSE
  3916.         IMPORT_CFM_FUNCTION    LMGetTimeSCCDB
  3917.     ENDIF
  3918.  
  3919. ;
  3920. ; pascal void LMSetTimeSCCDB(SInt16 value)
  3921. ;
  3922.     IF ¬ GENERATINGCFM THEN
  3923.         Macro
  3924.         _LMSetTimeSCCDB         &src=(sp)+
  3925.         move.w               &src,$0D02
  3926.         EndM
  3927.     ELSE
  3928.         IMPORT_CFM_FUNCTION    LMSetTimeSCCDB
  3929.     ENDIF
  3930.  
  3931. ;
  3932. ; pascal UniversalProcPtr LMGetJVBLTask(void)
  3933. ;
  3934.     IF ¬ GENERATINGCFM THEN
  3935.         Macro
  3936.         _LMGetJVBLTask         &dest=(sp)
  3937.         move.l               $0D28,&dest
  3938.         EndM
  3939.     ELSE
  3940.         IMPORT_CFM_FUNCTION    LMGetJVBLTask
  3941.     ENDIF
  3942.  
  3943. ;
  3944. ; pascal void LMSetJVBLTask(UniversalProcPtr value)
  3945. ;
  3946.     IF ¬ GENERATINGCFM THEN
  3947.         Macro
  3948.         _LMSetJVBLTask         &src=(sp)+
  3949.         move.l               &src,$0D28
  3950.         EndM
  3951.     ELSE
  3952.         IMPORT_CFM_FUNCTION    LMSetJVBLTask
  3953.     ENDIF
  3954.  
  3955. ;
  3956. ; pascal Handle LMGetSynListHandle(void)
  3957. ;
  3958.     IF ¬ GENERATINGCFM THEN
  3959.         Macro
  3960.         _LMGetSynListHandle         &dest=(sp)
  3961.         move.l               $0D32,&dest
  3962.         EndM
  3963.     ELSE
  3964.         IMPORT_CFM_FUNCTION    LMGetSynListHandle
  3965.     ENDIF
  3966.  
  3967. ;
  3968. ; pascal void LMSetSynListHandle(Handle value)
  3969. ;
  3970.     IF ¬ GENERATINGCFM THEN
  3971.         Macro
  3972.         _LMSetSynListHandle         &src=(sp)+
  3973.         move.l               &src,$0D32
  3974.         EndM
  3975.     ELSE
  3976.         IMPORT_CFM_FUNCTION    LMSetSynListHandle
  3977.     ENDIF
  3978.  
  3979. ;
  3980. ; pascal MCTableHandle LMGetMenuCInfo(void)
  3981. ;
  3982.     IF ¬ GENERATINGCFM THEN
  3983.         Macro
  3984.         _LMGetMenuCInfo         &dest=(sp)
  3985.         move.l               $0D50,&dest
  3986.         EndM
  3987.     ELSE
  3988.         IMPORT_CFM_FUNCTION    LMGetMenuCInfo
  3989.     ENDIF
  3990.  
  3991. ;
  3992. ; pascal void LMSetMenuCInfo(MCTableHandle value)
  3993. ;
  3994.     IF ¬ GENERATINGCFM THEN
  3995.         Macro
  3996.         _LMSetMenuCInfo         &src=(sp)+
  3997.         move.l               &src,$0D50
  3998.         EndM
  3999.     ELSE
  4000.         IMPORT_CFM_FUNCTION    LMSetMenuCInfo
  4001.     ENDIF
  4002.  
  4003. ;
  4004. ; pascal UniversalProcPtr LMGetJDTInstall(void)
  4005. ;
  4006.     IF ¬ GENERATINGCFM THEN
  4007.         Macro
  4008.         _LMGetJDTInstall         &dest=(sp)
  4009.         move.l               $0D9C,&dest
  4010.         EndM
  4011.     ELSE
  4012.         IMPORT_CFM_FUNCTION    LMGetJDTInstall
  4013.     ENDIF
  4014.  
  4015. ;
  4016. ; pascal void LMSetJDTInstall(UniversalProcPtr value)
  4017. ;
  4018.     IF ¬ GENERATINGCFM THEN
  4019.         Macro
  4020.         _LMSetJDTInstall         &src=(sp)+
  4021.         move.l               &src,$0D9C
  4022.         EndM
  4023.     ELSE
  4024.         IMPORT_CFM_FUNCTION    LMSetJDTInstall
  4025.     ENDIF
  4026.  
  4027. ;
  4028. ; pascal SInt16 LMGetTimeSCSIDB(void)
  4029. ;
  4030.     IF ¬ GENERATINGCFM THEN
  4031.         Macro
  4032.         _LMGetTimeSCSIDB         &dest=(sp)
  4033.         move.w               $0B24,&dest
  4034.         EndM
  4035.     ELSE
  4036.         IMPORT_CFM_FUNCTION    LMGetTimeSCSIDB
  4037.     ENDIF
  4038.  
  4039. ;
  4040. ; pascal void LMSetTimeSCSIDB(SInt16 value)
  4041. ;
  4042.     IF ¬ GENERATINGCFM THEN
  4043.         Macro
  4044.         _LMSetTimeSCSIDB         &src=(sp)+
  4045.         move.w               &src,$0B24
  4046.         EndM
  4047.     ELSE
  4048.         IMPORT_CFM_FUNCTION    LMSetTimeSCSIDB
  4049.     ENDIF
  4050.  
  4051. ;*************************************************************************************
  4052. ;
  4053. ;    MORE COMPLEX LOWMEM ACCESSORS
  4054. ;
  4055. ;*************************************************************************************
  4056.     IF CFMSYSTEMCALLS  THEN
  4057. ;
  4058. ; pascal void LMGetDSAlertRect(Rect *dsAlertRectValue)
  4059. ;
  4060.     IF GENERATINGCFM THEN
  4061.         IMPORT_CFM_FUNCTION    LMGetDSAlertRect
  4062.     ENDIF
  4063.  
  4064. ;
  4065. ; pascal void LMSetDSAlertRect(const Rect *dsAlertRectValue)
  4066. ;
  4067.     IF GENERATINGCFM THEN
  4068.         IMPORT_CFM_FUNCTION    LMSetDSAlertRect
  4069.     ENDIF
  4070.  
  4071. ;
  4072. ; pascal void LMGetDragPattern(Pattern *dragPatternValue)
  4073. ;
  4074.     IF GENERATINGCFM THEN
  4075.         IMPORT_CFM_FUNCTION    LMGetDragPattern
  4076.     ENDIF
  4077.  
  4078. ;
  4079. ; pascal void LMSetDragPattern(const Pattern *dragPatternValue)
  4080. ;
  4081.     IF GENERATINGCFM THEN
  4082.         IMPORT_CFM_FUNCTION    LMSetDragPattern
  4083.     ENDIF
  4084.  
  4085. ;
  4086. ; pascal void LMGetDeskPattern(Pattern *deskPatternValue)
  4087. ;
  4088.     IF GENERATINGCFM THEN
  4089.         IMPORT_CFM_FUNCTION    LMGetDeskPattern
  4090.     ENDIF
  4091.  
  4092. ;
  4093. ; pascal void LMSetDeskPattern(const Pattern *deskPatternValue)
  4094. ;
  4095.     IF GENERATINGCFM THEN
  4096.         IMPORT_CFM_FUNCTION    LMSetDeskPattern
  4097.     ENDIF
  4098.  
  4099. ;
  4100. ; pascal void LMGetHiliteRGB(RGBColor *hiliteRGBValue)
  4101. ;
  4102.     IF GENERATINGCFM THEN
  4103.         IMPORT_CFM_FUNCTION    LMGetHiliteRGB
  4104.     ENDIF
  4105.  
  4106. ;
  4107. ; pascal void LMSetHiliteRGB(const RGBColor *hiliteRGBValue)
  4108. ;
  4109.     IF GENERATINGCFM THEN
  4110.         IMPORT_CFM_FUNCTION    LMSetHiliteRGB
  4111.     ENDIF
  4112.  
  4113. ;
  4114. ; pascal QHdrPtr LMGetEventQueue(void)
  4115. ;
  4116.     IF GENERATINGCFM THEN
  4117.         IMPORT_CFM_FUNCTION    LMGetEventQueue
  4118.     ENDIF
  4119.  
  4120. ;
  4121. ; pascal void LMSetEventQueue(QHdrPtr eventQueueValue)
  4122. ;
  4123.     IF GENERATINGCFM THEN
  4124.         IMPORT_CFM_FUNCTION    LMSetEventQueue
  4125.     ENDIF
  4126.  
  4127. ;
  4128. ; pascal QHdrPtr LMGetVBLQueue(void)
  4129. ;
  4130.     IF GENERATINGCFM THEN
  4131.         IMPORT_CFM_FUNCTION    LMGetVBLQueue
  4132.     ENDIF
  4133.  
  4134. ;
  4135. ; pascal void LMSetVBLQueue(QHdrPtr vblQueueValue)
  4136. ;
  4137.     IF GENERATINGCFM THEN
  4138.         IMPORT_CFM_FUNCTION    LMSetVBLQueue
  4139.     ENDIF
  4140.  
  4141. ;
  4142. ; pascal QHdrPtr LMGetDrvQHdr(void)
  4143. ;
  4144.     IF GENERATINGCFM THEN
  4145.         IMPORT_CFM_FUNCTION    LMGetDrvQHdr
  4146.     ENDIF
  4147.  
  4148. ;
  4149. ; pascal void LMSetDrvQHdr(QHdrPtr drvQHdrValue)
  4150. ;
  4151.     IF GENERATINGCFM THEN
  4152.         IMPORT_CFM_FUNCTION    LMSetDrvQHdr
  4153.     ENDIF
  4154.  
  4155. ;
  4156. ; pascal QHdrPtr LMGetVCBQHdr(void)
  4157. ;
  4158.     IF GENERATINGCFM THEN
  4159.         IMPORT_CFM_FUNCTION    LMGetVCBQHdr
  4160.     ENDIF
  4161.  
  4162. ;
  4163. ; pascal void LMSetVCBQHdr(QHdrPtr vcbQHdrValue)
  4164. ;
  4165.     IF GENERATINGCFM THEN
  4166.         IMPORT_CFM_FUNCTION    LMSetVCBQHdr
  4167.     ENDIF
  4168.  
  4169. ;
  4170. ; pascal QHdrPtr LMGetDTQueue(void)
  4171. ;
  4172.     IF GENERATINGCFM THEN
  4173.         IMPORT_CFM_FUNCTION    LMGetDTQueue
  4174.     ENDIF
  4175.  
  4176. ;
  4177. ; pascal void LMSetDTQueue(QHdrPtr dtQueueValue)
  4178. ;
  4179.     IF GENERATINGCFM THEN
  4180.         IMPORT_CFM_FUNCTION    LMSetDTQueue
  4181.     ENDIF
  4182.  
  4183. ;
  4184. ; pascal QHdrPtr LMGetFSQHdr(void)
  4185. ;
  4186.     IF GENERATINGCFM THEN
  4187.         IMPORT_CFM_FUNCTION    LMGetFSQHdr
  4188.     ENDIF
  4189.  
  4190. ;*************************************************************************************
  4191. ;    "BLOCKMOVE ACCESSORS"
  4192. ;    
  4193. ;        These lowmem accessors use the BlockMove trap
  4194. ;*************************************************************************************
  4195. ;
  4196. ; pascal StringPtr LMGetCurApName(void)
  4197. ;
  4198.     IF GENERATINGCFM THEN
  4199.         IMPORT_CFM_FUNCTION    LMGetCurApName
  4200.     ENDIF
  4201.  
  4202. ;
  4203. ; pascal void LMSetCurApName(ConstStr31Param curApNameValue)
  4204. ;
  4205.     IF GENERATINGCFM THEN
  4206.         IMPORT_CFM_FUNCTION    LMSetCurApName
  4207.     ENDIF
  4208.  
  4209. ;
  4210. ; pascal StringPtr LMGetSysResName(void)
  4211. ;
  4212.     IF GENERATINGCFM THEN
  4213.         IMPORT_CFM_FUNCTION    LMGetSysResName
  4214.     ENDIF
  4215.  
  4216. ;
  4217. ; pascal void LMSetSysResName(ConstStr15Param sysResNameValue)
  4218. ;
  4219.     IF GENERATINGCFM THEN
  4220.         IMPORT_CFM_FUNCTION    LMSetSysResName
  4221.     ENDIF
  4222.  
  4223. ;
  4224. ; pascal StringPtr LMGetFinderName(void)
  4225. ;
  4226.     IF GENERATINGCFM THEN
  4227.         IMPORT_CFM_FUNCTION    LMGetFinderName
  4228.     ENDIF
  4229.  
  4230. ;
  4231. ; pascal void LMSetFinderName(ConstStr15Param finderNameValue)
  4232. ;
  4233.     IF GENERATINGCFM THEN
  4234.         IMPORT_CFM_FUNCTION    LMSetFinderName
  4235.     ENDIF
  4236.  
  4237. ;
  4238. ; pascal Ptr LMGetScratch20(void)
  4239. ;
  4240.     IF GENERATINGCFM THEN
  4241.         IMPORT_CFM_FUNCTION    LMGetScratch20
  4242.     ENDIF
  4243.  
  4244. ;
  4245. ; pascal void LMSetScratch20(const void *scratch20Value)
  4246. ;
  4247.     IF GENERATINGCFM THEN
  4248.         IMPORT_CFM_FUNCTION    LMSetScratch20
  4249.     ENDIF
  4250.  
  4251. ;
  4252. ; pascal Ptr LMGetToolScratch(void)
  4253. ;
  4254.     IF GENERATINGCFM THEN
  4255.         IMPORT_CFM_FUNCTION    LMGetToolScratch
  4256.     ENDIF
  4257.  
  4258. ;
  4259. ; pascal void LMSetToolScratch(const void *toolScratchValue)
  4260. ;
  4261.     IF GENERATINGCFM THEN
  4262.         IMPORT_CFM_FUNCTION    LMSetToolScratch
  4263.     ENDIF
  4264.  
  4265. ;
  4266. ; pascal Ptr LMGetApplScratch(void)
  4267. ;
  4268.     IF GENERATINGCFM THEN
  4269.         IMPORT_CFM_FUNCTION    LMGetApplScratch
  4270.     ENDIF
  4271.  
  4272. ;
  4273. ; pascal void LMSetApplScratch(const void *applScratchValue)
  4274. ;
  4275.     IF GENERATINGCFM THEN
  4276.         IMPORT_CFM_FUNCTION    LMSetApplScratch
  4277.     ENDIF
  4278.  
  4279. ;*************************************************************************************
  4280. ;    "INDEXED ACCESSORS"
  4281. ;    
  4282. ;        These lowmem accessors take an index parameter to get/set an indexed
  4283. ;        lowmem global.
  4284. ;*************************************************************************************
  4285. ;
  4286. ; pascal StringHandle LMGetDAStrings(short whichString)
  4287. ;
  4288.     IF GENERATINGCFM THEN
  4289.         IMPORT_CFM_FUNCTION    LMGetDAStrings
  4290.     ENDIF
  4291.  
  4292. ;
  4293. ; pascal void LMSetDAStrings(StringHandle stringsValue, short whichString)
  4294. ;
  4295.     IF GENERATINGCFM THEN
  4296.         IMPORT_CFM_FUNCTION    LMSetDAStrings
  4297.     ENDIF
  4298.  
  4299. ;
  4300. ; pascal UniversalProcPtr LMGetLvl2DT(short vectorNumber)
  4301. ;
  4302.     IF GENERATINGCFM THEN
  4303.         IMPORT_CFM_FUNCTION    LMGetLvl2DT
  4304.     ENDIF
  4305.  
  4306. ;
  4307. ; pascal void LMSetLvl2DT(UniversalProcPtr Lvl2DTValue, short vectorNumber)
  4308. ;
  4309.     IF GENERATINGCFM THEN
  4310.         IMPORT_CFM_FUNCTION    LMSetLvl2DT
  4311.     ENDIF
  4312.  
  4313. ;
  4314. ; pascal UniversalProcPtr LMGetExtStsDT(short vectorNumber)
  4315. ;
  4316.     IF GENERATINGCFM THEN
  4317.         IMPORT_CFM_FUNCTION    LMGetExtStsDT
  4318.     ENDIF
  4319.  
  4320. ;
  4321. ; pascal void LMSetExtStsDT(UniversalProcPtr ExtStsDTValue, short vectorNumber)
  4322. ;
  4323.     IF GENERATINGCFM THEN
  4324.         IMPORT_CFM_FUNCTION    LMSetExtStsDT
  4325.     ENDIF
  4326.  
  4327.     ENDIF
  4328.     ENDIF ; __LOWMEM__
  4329.